Remove the outermost folded frame for terse stack traces.

lib/src/trace.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 trace;
 
 import 'dart:collection';
 import 'dart:math' as math;
 
 import 'chain.dart';
@@ skipping 184 matching lines @@
   /// The return value's [toString] method will always return a string
   /// representation in the Dart VM's stack trace format, regardless of what
   /// platform is being used.
   StackTrace get vmTrace => new VMTrace(frames);
 
   /// Returns a terser version of [this].
   ///
   /// This is accomplished by folding together multiple stack frames from the
   /// core library or from this package, as in [foldFrames]. Remaining core
   /// library frames have their libraries, "-patch" suffixes, and line numbers
-  /// removed.
+  /// removed. If the outermost frame of the stack trace is a core library
+  /// frame, it's removed entirely.
   ///
   /// For custom folding, see [foldFrames].
   Trace get terse => foldFrames((_) => false, terse: true);
 
   /// Returns a new [Trace] based on [this] where multiple stack frames matching
   /// [predicate] are folded together.
   ///
   /// This means that whenever there are multiple frames in a row that match
   /// [predicate], only the last one is kept. This is useful for limiting the
   /// amount of library code that appears in a stack trace by only showing user
   /// code and code that's called by user code.
   ///
   /// If [terse] is true, this will also fold together frames from the core
-  /// library or from this package, and simplify core library frames as in
-  /// [Trace.terse].
+  /// library or from this package, simplify core library frames, and
+  /// potentially remove the outermost frame as in [Trace.terse].
   Trace foldFrames(bool predicate(Frame frame), {bool terse: false}) {
     if (terse) {
       var oldPredicate = predicate;
       predicate = (frame) {
         if (oldPredicate(frame)) return true;
 
         if (frame.isCore) return true;
         if (frame.package == 'stack_trace') return true;
 
         // Ignore async stack frames without any line or column information.
@@ skipping 17 matching lines @@
             frame.uri, frame.line, frame.column, frame.member));
       }
     }
 
     if (terse) {
       newFrames = newFrames.map((frame) {
         if (!frame.isCore) return frame;
         var library = frame.library.replaceAll(_terseRegExp, '');
         return new Frame(Uri.parse(library), null, null, frame.member);
       }).toList();
+      if (newFrames.first.isCore && newFrames.length > 1) newFrames.removeAt(0);
     }
 
     return new Trace(newFrames.reversed);
   }
 
   /// Returns a human-readable string representation of [this].
   String toString() {
     // Figure out the longest path so we know how much to pad.
     var longest = frames.map((frame) => frame.location.length)
         .fold(0, math.max);
 
     // Print out the stack trace nicely formatted.
     return frames.map((frame) {
       return '${padRight(frame.location, longest)}  ${frame.member}\n';
     }).join();
   }
 }