Don't throw for unparseable frames.

lib/src/frame.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 frame;
 
 import 'package:path/path.dart' as path;
 
 import 'trace.dart';
+import 'unparsed_frame.dart';
 
 // #1      Foo._bar (file:///home/nweiz/code/stuff.dart:42:21)
 // #1      Foo._bar (file:///home/nweiz/code/stuff.dart:42)
 // #1      Foo._bar (file:///home/nweiz/code/stuff.dart)
 final _vmFrame = new RegExp(r'^#\d+\s+(\S.*) \((.+?)((?::\d+){0,2})\)$');
 
 //     at Object.stringify (native)
 //     at VW.call$0 (http://pub.dartlang.org/stuff.dart.js:560:28)
 //     at VW.call$0 (eval as fn
 //         (http://pub.dartlang.org/stuff.dart.js:560:28), efn:3:28)
@@ skipping 99 matching lines @@
   factory Frame.caller([int level=1]) {
     if (level < 0) {
       throw new ArgumentError("Argument [level] must be greater than or equal "
           "to 0.");
     }
 
     return new Trace.current(level + 1).frames.first;
   }
 
   /// Parses a string representation of a Dart VM stack frame.
-  factory Frame.parseVM(String frame) {
+  factory Frame.parseVM(String frame) => _catchFormatException(frame, () {
     // The VM sometimes folds multiple stack frames together and replaces them
     // with "...".
     if (frame == '...') {
       return new Frame(new Uri(), null, null, '...');
     }
 
     var match = _vmFrame.firstMatch(frame);
-    if (match == null) {
-      throw new FormatException("Couldn't parse VM stack trace line '$frame'.");
-    }
+    if (match == null) return new UnparsedFrame(frame);
 
     // Get the pieces out of the regexp match. Function, URI and line should
     // always be found. The column is optional.
     var member = match[1]
         .replaceAll(_asyncBody, "<async>")
         .replaceAll("<anonymous closure>", "<fn>");
     var uri = Uri.parse(match[2]);
 
     var lineAndColumn = match[3].split(':');
     var line = lineAndColumn.length > 1 ? int.parse(lineAndColumn[1]) : null;
     var column = lineAndColumn.length > 2 ? int.parse(lineAndColumn[2]) : null;
     return new Frame(uri, line, column, member);
-  }
+  });
 
   /// Parses a string representation of a Chrome/V8 stack frame.
-  factory Frame.parseV8(String frame) {
+  factory Frame.parseV8(String frame) => _catchFormatException(frame, () {
     var match = _v8Frame.firstMatch(frame);
-    if (match == null) {
-      throw new FormatException("Couldn't parse V8 stack trace line '$frame'.");
-    }
+    if (match == null) return new UnparsedFrame(frame);
 
     // v8 location strings can be arbitrarily-nested, since it adds a layer of
     // nesting for each eval performed on that line.
     parseLocation(location, member) {
       var evalMatch = _v8EvalLocation.firstMatch(location);
       while (evalMatch != null) {
         location = evalMatch[1];
         evalMatch = _v8EvalLocation.firstMatch(location);
       }
 
       if (location == 'native') {
         return new Frame(Uri.parse('native'), null, null, member);
       }
 
       var urlMatch = _v8UrlLocation.firstMatch(location);
-      if (urlMatch == null) {
-        throw new FormatException(
-            "Couldn't parse V8 stack trace line '$frame'.");
-      }
+      if (urlMatch == null) return new UnparsedFrame(frame);
 
       return new Frame(
           _uriOrPathToUri(urlMatch[1]),
           int.parse(urlMatch[2]),
           int.parse(urlMatch[3]),
           member);
     }
 
     // V8 stack frames can be in two forms.
     if (match[2] != null) {
       // The first form looks like " at FUNCTION (LOCATION)". V8 proper lists
       // anonymous functions within eval as "<anonymous>", while IE10 lists them
       // as "Anonymous function".
       return parseLocation(match[2],
           match[1].replaceAll("<anonymous>", "<fn>")
                   .replaceAll("Anonymous function", "<fn>"));
     } else {
       // The second form looks like " at LOCATION", and is used for anonymous
       // functions.
       return parseLocation(match[3], "<fn>");
     }
-  }
+  });
 
   /// Parses a string representation of a JavaScriptCore stack trace.
   factory Frame.parseJSCore(String frame) => new Frame.parseV8(frame);
 
   /// Parses a string representation of an IE stack frame.
   ///
   /// IE10+ frames look just like V8 frames. Prior to IE10, stack traces can't
   /// be retrieved.
   factory Frame.parseIE(String frame) => new Frame.parseV8(frame);
 
   /// Parses a string representation of a Firefox stack frame.
-  factory Frame.parseFirefox(String frame) {
+  factory Frame.parseFirefox(String frame) => _catchFormatException(frame, () {
     var match = _firefoxSafariFrame.firstMatch(frame);
-    if (match == null) {
-      throw new FormatException(
-          "Couldn't parse Firefox/Safari stack trace line '$frame'.");
-    }
+    if (match == null) return new UnparsedFrame(frame);
 
     // Normally this is a URI, but in a jsshell trace it can be a path.
     var uri = _uriOrPathToUri(match[3]);
 
     var member;
     if (match[1] != null) {
       member = match[1];
       member +=
           new List.filled('/'.allMatches(match[2]).length, ".<fn>").join();
       if (member == '') member = '<fn>';
 
       // Some Firefox members have initial dots. We remove them for consistency
       // with other platforms.
       member = member.replaceFirst(_initialDot, '');
     } else {
       member = '<fn>';
     }
 
     var line = match[4] == '' ? null : int.parse(match[4]);
     var column = match[5] == null || match[5] == '' ?
         null : int.parse(match[5]);
     return new Frame(uri, line, column, member);
-  }
+  });
 
   /// Parses a string representation of a Safari 6.0 stack frame.
   @Deprecated("Use Frame.parseSafari instead.")
   factory Frame.parseSafari6_0(String frame) => new Frame.parseFirefox(frame);
 
   /// Parses a string representation of a Safari 6.1+ stack frame.
   @Deprecated("Use Frame.parseSafari instead.")
   factory Frame.parseSafari6_1(String frame) => new Frame.parseFirefox(frame);
 
   /// Parses a string representation of a Safari stack frame.
   factory Frame.parseSafari(String frame) => new Frame.parseFirefox(frame);
 
   /// Parses this package's string representation of a stack frame.
-  factory Frame.parseFriendly(String frame) {
+  factory Frame.parseFriendly(String frame) => _catchFormatException(frame, () {
     var match = _friendlyFrame.firstMatch(frame);
     if (match == null) {
       throw new FormatException(
           "Couldn't parse package:stack_trace stack trace line '$frame'.");
     }
 
     var uri = Uri.parse(match[1]);
     // If there's no scheme, this is a relative URI. We should interpret it as
     // relative to the current working directory.
     if (uri.scheme == '') {
       uri = path.toUri(path.absolute(path.fromUri(uri)));
     }
 
     var line = match[2] == null ? null : int.parse(match[2]);
     var column = match[3] == null ? null : int.parse(match[3]);
     return new Frame(uri, line, column, match[4]);
-  }
+  });
 
   /// A regular expression matching an absolute URI.
   static final _uriRegExp = new RegExp(r'^[a-zA-Z][-+.a-zA-Z\d]*://');
 
   /// A regular expression matching a Windows path.
   static final _windowsRegExp = new RegExp(r'^([a-zA-Z]:[\\/]|\\\\)');
 
   /// Converts [uriOrPath], which can be a URI, a Windows path, or a Posix path,
   /// to a URI (absolute if possible).
   static Uri _uriOrPathToUri(String uriOrPath) {
     if (uriOrPath.contains(_uriRegExp)) {
       return Uri.parse(uriOrPath);
     } else if (uriOrPath.contains(_windowsRegExp)) {
       return new Uri.file(uriOrPath, windows: true);
     } else if (uriOrPath.startsWith('/')) {
       return new Uri.file(uriOrPath, windows: false);
     }
 
     // As far as I've seen, Firefox and V8 both always report absolute paths in
     // their stack frames. However, if we do get a relative path, we should
     // handle it gracefully.
     if (uriOrPath.contains('\\')) return path.windows.toUri(uriOrPath);
     return Uri.parse(uriOrPath);
   }
 
+  /// Runs [body] and returns its result.
+  ///
+  /// If [body] throws a [FormatException], returns an [UnparsedFrame] with
+  /// [text] instead.
+  static Frame _catchFormatException(String text, Frame body()) {
+    try {
+      return body();
+    } on FormatException catch (_) {
+      return new UnparsedFrame(text);
+    }
+  }
+
   Frame(this.uri, this.line, this.column, this.member);
 
   String toString() => '$location in $member';
 }