Ensure that errors have stack traces attached.

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 pub.utils;
 
 import 'dart:async';
 import "dart:collection";
 import "dart:convert";
@@ skipping 46 matching lines @@
     futures.add(task.then((value) {
       if (completed) return;
 
       _pending--;
       _values.add(value);
 
       if (_pending <= 0) {
         completed = true;
         _completer.complete(_values);
       }
-    }).catchError((e) {
+    }).catchError((e, stackTrace) {
       if (completed) return;
 
       completed = true;
-      _completer.completeError(e);
+      _completer.completeError(e, stackTrace);
     }));
 
     return task;
   }
 
   Future<List> get future => _completer.future;
 }
 
 /// Like [new Future], but avoids around issue 11911 by using [new Future.value]
 /// under the covers.
@@ skipping 203 matching lines @@
 /// Returns the hex-encoded sha1 hash of [source].
 String sha1(String source) {
   var sha = new SHA1();
   sha.add(source.codeUnits);
   return CryptoUtils.bytesToHex(sha.close());
 }
 
 /// Configures [future] so that its result (success or exception) is passed on
 /// to [completer].
 void chainToCompleter(Future future, Completer completer) {
-  future.then((value) => completer.complete(value),
-      onError: (e) => completer.completeError(e));
+  future.then(completer.complete, onError: completer.completeError);
 }
 
 /// Ensures that [stream] can emit at least one value successfully (or close
 /// without any values).
 ///
 /// For example, reading asynchronously from a non-existent file will return a
 /// stream that fails on the first chunk. In order to handle that more
 /// gracefully, you may want to check that the stream looks like it's working
 /// before you pipe the stream to something else.
 ///
@@ skipping 327 matching lines @@
 ///   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.
   newFuture(fn).then((val) {
     scheduleMicrotask(() => completer.complete(val));
-  }).catchError((err) {
-    scheduleMicrotask(() => completer.completeError(err));
+  }).catchError((err, stackTrace) {
+    scheduleMicrotask(() => completer.completeError(err, stackTrace));
   });
   return completer.future;
 }
 
 /// The subset of strings that don't need quoting in YAML. This pattern does
 /// not strictly follow the plain scalar grammar of YAML, which means some
 /// strings may be unnecessarily quoted, but it's much simpler.
 final _unquotableYamlString = new RegExp(r"^[a-zA-Z_-][a-zA-Z_0-9-]*$");
 
 /// Converts [data], which is a parsed YAML object, to a pretty-printed string,
@@ skipping 121 matching lines @@
     error is AnalyzerErrorGroup ||
     error is IsolateSpawnException ||
     error is FileSystemException ||
     error is HttpException ||
     error is HttpException ||
     error is OSError ||
     error is ProcessException ||
     error is SocketException ||
     error is WebSocketException;
 }