Make pkg/stack_trace use stack chains.

pkg/scheduled_test/lib/src/utils.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.
 
 library utils;
 
 import 'dart:async';
 
 import 'package:stack_trace/stack_trace.dart';
 
@@ skipping 13 matching lines @@
 
   int get hashCode => first.hashCode ^ last.hashCode;
 }
 
 /// Configures [future] so that its result (success or exception) is passed on
 /// to [completer].
 void chainToCompleter(Future future, Completer completer) {
   future.then(completer.complete, onError: completer.completeError);
 }
 
+/// Like [Future.sync], but wraps the Future in [Chain.track] as well.
+Future syncFuture(callback()) => Chain.track(new Future.sync(callback));

[Bob Nystrom, 2013/12/03 22:24:47]

Why is this needed? Does this not go through the zone stuff?

[nweiz, 2013/12/03 22:34:32]

No; Future.sync has its own try/catch that applies within the callback that's
passed to the zone specification. Issue 15105 is tracking this.

+
 /// Prepends each line in [text] with [prefix]. If [firstPrefix] is passed, the
 /// first line is prefixed with that instead.
 String prefixLines(String text, {String prefix: '| ', String firstPrefix}) {
   var lines = text.split('\n');
   if (firstPrefix == null) {
     return lines.map((line) => '$prefix$line').join('\n');
   }
 
   var firstLine = "$firstPrefix${lines.first}";
   lines = lines.skip(1).map((line) => '$prefix$line').toList();
@@ skipping 21 matching lines @@
 
   while (true) {
     var hasNext1 = iter1.moveNext();
     var hasNext2 = iter2.moveNext();
     if (hasNext1 != hasNext2) return false;
     if (!hasNext1) return true;
     if (iter1.current != iter2.current) return false;
   }
 }
 
-// TODO(nweiz): remove this when issue 8731 is fixed.
-/// Returns a [Stream] that will immediately emit [error] and then close.
-Stream errorStream(error) => new Future.error(error).asStream();
-
 /// Returns a buffered stream that will emit the same values as the stream
 /// returned by [future] once [future] completes.
 ///
 /// If [future] completes to an error, the return value will emit that error and
 /// then close.
 ///
 /// If [broadcast] is true, a broadcast stream is returned. This assumes that
 /// the stream returned by [future] will be a broadcast stream as well.
 /// [broadcast] defaults to false.
 Stream futureStream(Future<Stream> future, {bool broadcast: false}) {
@@ skipping 31 matching lines @@
     controller = new StreamController(
         sync: true, onListen: onListen, onCancel: onCancel);
   }
   return controller.stream;
 }
 
 /// Returns the first element of a [StreamIterator].
 ///
 /// If the [StreamIterator] has no elements, the result is a state error.
 Future<String> streamIteratorFirst(StreamIterator<String> streamIterator) {
-  StackTrace stackTrace = new Trace.current();
   return streamIterator.moveNext().then((hasNext) {
     if (hasNext) {
       return streamIterator.current;
     } else {
-      return new Future.error(new StateError("No elements"), stackTrace);
+      throw new StateError("No elements");
     }
   });
 }
 
 /// Collects all remaining lines from a [StreamIterator] of lines.
 ///
 /// Returns the concatenation of the collected lines joined by newlines.
 Future<String> concatRest(StreamIterator<String> streamIterator) {
   var completer = new Completer<String>();
   var buffer = new StringBuffer();
@@ skipping 80 matching lines @@
 /// Returns whether [pattern] matches all of [string].
 bool fullMatch(String string, Pattern pattern) {
   var matches = pattern.allMatches(string);
   if (matches.isEmpty) return false;
   return matches.first.start == 0 && matches.first.end == string.length;
 }
 
 /// Returns a string representation of [trace] that has the core and test frames
 /// folded together.
 String terseTraceString(StackTrace trace) {
-  return new Trace.from(trace).terse.foldFrames((frame) {
-    return frame.package == 'scheduled_test' || frame.package == 'unittest' ||
-        frame.isCore;
-  }).toString().trim();
+  return new Chain(new Chain.forTrace(trace).traces.map((trace) {
+    return trace.foldFrames((frame) {
+      return frame.package == 'scheduled_test' || frame.package == 'unittest' ||
+          frame.package == 'stack_trace' || frame.isCore;

[Bob Nystrom, 2013/12/03 22:24:47]

How do you feel about wrapping each to its own line and lining them up?

return frame.package == 'scheduled_test' ||
       frame.package == 'unittest' ||
       frame.package == 'stack_trace' ||
       frame.isCore;

[nweiz, 2013/12/03 22:34:32]

Done.

+    });
+  })).terse.toString().trim();
 }