Switch to actual unittest, stack trace, and path packages. Tag tests as failing that were ignored d…

test/codegen/expect/stack_trace/stack_trace.js

+dart_library.library('stack_trace', null, /* Imports */[
+  'dart_sdk',
+  'path'
+], function(exports, dart_sdk, path) {
+  'use strict';
+  const core = dart_sdk.core;
+  const collection = dart_sdk.collection;
+  const math = dart_sdk.math;
+  const async = dart_sdk.async;
+  const dart = dart_sdk.dart;
+  const dartx = dart_sdk.dartx;
+  const path$ = path.path;
+  const src__trace = Object.create(null);
+  const src__chain = Object.create(null);
+  const src__vm_trace = Object.create(null);
+  const src__lazy_trace = Object.create(null);
+  const src__utils = Object.create(null);
+  const src__frame = Object.create(null);
+  const src__stack_zone_specification = Object.create(null);
+  const src__unparsed_frame = Object.create(null);
+  const stack_trace = Object.create(null);
+  dart.defineLazy(src__trace, {
+    get _terseRegExp() {
+      return core.RegExp.new("(-patch)?([/\\\\].*)?$");
+    }
+  });
+  dart.defineLazy(src__trace, {
+    get _v8Trace() {
+      return core.RegExp.new("\\n    ?at ");
+    }
+  });
+  dart.defineLazy(src__trace, {
+    get _v8TraceLine() {
+      return core.RegExp.new("    ?at ");
+    }
+  });
+  dart.defineLazy(src__trace, {
+    get _firefoxSafariTrace() {
+      return core.RegExp.new("^" + "(" + "([.0-9A-Za-z_$/<]|\\(.*\\))*" + "@" + ")?" + "[^\\s]*" + ":\\d*" + "$", {multiLine: true});
+    }
+  });
+  dart.defineLazy(src__trace, {
+    get _friendlyTrace() {
+      return core.RegExp.new("^[^\\s]+( \\d+(:\\d+)?)?[ \\t]+[^\\s]+$", {multiLine: true});
+    }
+  });
+  src__trace.Trace = class Trace extends core.Object {
+    static format(stackTrace, opts) {
+      let terse = opts && 'terse' in opts ? opts.terse : true;
+      let trace = src__trace.Trace.from(stackTrace);
+      if (dart.notNull(terse)) trace = trace.terse;
+      return dart.toString(trace);
+    }
+    static current(level) {
+      if (level === void 0) level = 0;
+      if (dart.notNull(level) < 0) {
+        dart.throw(new core.ArgumentError("Argument [level] must be greater than or equal " + "to 0."));
+      }
+      let trace = src__trace.Trace.from(core.StackTrace.current);
+      return new src__lazy_trace.LazyTrace(dart.fn(() => new src__trace.Trace(trace.frames[dartx.skip](dart.notNull(level) + 1)), src__trace.Trace, []));
+    }
+    static from(trace) {
+      if (trace == null) {
+        dart.throw(new core.ArgumentError("Cannot create a Trace from null."));
+      }
+      if (dart.is(trace, src__trace.Trace)) return trace;
+      if (dart.is(trace, src__chain.Chain)) return trace.toTrace();
+      return new src__lazy_trace.LazyTrace(dart.fn(() => src__trace.Trace.parse(dart.toString(trace)), src__trace.Trace, []));
+    }
+    static parse(trace) {
+      try {
+        if (dart.notNull(trace[dartx.isEmpty])) return new src__trace.Trace(dart.list([], src__frame.Frame));
+        if (dart.notNull(trace[dartx.contains](src__trace._v8Trace))) return new src__trace.Trace.parseV8(trace);
+        if (dart.notNull(trace[dartx.contains]("\tat "))) return new src__trace.Trace.parseJSCore(trace);
+        if (dart.notNull(trace[dartx.contains](src__trace._firefoxSafariTrace))) {
+          return new src__trace.Trace.parseFirefox(trace);
+        }
+        if (dart.notNull(trace[dartx.contains](src__utils.chainGap))) return src__chain.Chain.parse(trace).toTrace();
+        if (dart.notNull(trace[dartx.contains](src__trace._friendlyTrace))) {
+          return new src__trace.Trace.parseFriendly(trace);
+        }
+        return new src__trace.Trace.parseVM(trace);
+      } catch (error) {
+        if (dart.is(error, core.FormatException)) {
+          dart.throw(new core.FormatException(`${error.message}\nStack trace:\n${trace}`));
+        } else
+          throw error;
+      }
+
+    }
+    parseVM(trace) {
+      this.Trace(src__trace.Trace._parseVM(trace));
+    }
+    static _parseVM(trace) {
+      let lines = trace[dartx.trim]()[dartx.split]("\n");
+      let frames = lines[dartx.take](dart.notNull(lines[dartx.length]) - 1)[dartx.map](src__frame.Frame)(dart.fn(line => src__frame.Frame.parseVM(line), src__frame.Frame, [core.String]))[dartx.toList]();
+      if (!dart.notNull(lines[dartx.last][dartx.endsWith](".da"))) {
+        frames[dartx.add](src__frame.Frame.parseVM(lines[dartx.last]));
+      }
+      return frames;
+    }
+    parseV8(trace) {
+      this.Trace(trace[dartx.split]("\n")[dartx.skip](1)[dartx.skipWhile](dart.fn(line => !dart.notNull(line[dartx.startsWith](src__trace._v8TraceLine)), core.bool, [core.String]))[dartx.map](src__frame.Frame)(dart.fn(line => src__frame.Frame.parseV8(line), src__frame.Frame, [core.String])));
+    }
+    parseJSCore(trace) {
+      this.Trace(trace[dartx.split]("\n")[dartx.where](dart.fn(line => line != "\tat ", core.bool, [core.String]))[dartx.map](src__frame.Frame)(dart.fn(line => src__frame.Frame.parseV8(line), src__frame.Frame, [core.String])));
+    }
+    parseIE(trace) {
+      this.parseV8(trace);
+    }
+    parseFirefox(trace) {
+      this.Trace(trace[dartx.trim]()[dartx.split]("\n")[dartx.where](dart.fn(line => dart.notNull(line[dartx.isNotEmpty]) && line != '[native code]', core.bool, [core.String]))[dartx.map](src__frame.Frame)(dart.fn(line => src__frame.Frame.parseFirefox(line), src__frame.Frame, [core.String])));
+    }
+    parseSafari(trace) {
+      this.parseFirefox(trace);
+    }
+    parseSafari6_1(trace) {
+      this.parseSafari(trace);
+    }
+    parseSafari6_0(trace) {
+      this.Trace(trace[dartx.trim]()[dartx.split]("\n")[dartx.where](dart.fn(line => line != '[native code]', core.bool, [core.String]))[dartx.map](src__frame.Frame)(dart.fn(line => src__frame.Frame.parseFirefox(line), src__frame.Frame, [core.String])));
+    }
+    parseFriendly(trace) {
+      this.Trace(dart.notNull(trace[dartx.isEmpty]) ? dart.list([], src__frame.Frame) : trace[dartx.trim]()[dartx.split]("\n")[dartx.where](dart.fn(line => !dart.notNull(line[dartx.startsWith]('=====')), core.bool, [core.String]))[dartx.map](src__frame.Frame)(dart.fn(line => src__frame.Frame.parseFriendly(line), src__frame.Frame, [core.String])));
+    }
+    Trace(frames) {
+      this.frames = new (collection.UnmodifiableListView$(src__frame.Frame))(frames[dartx.toList]());
+    }
+    get vmTrace() {
+      return new src__vm_trace.VMTrace(this.frames);
+    }
+    get terse() {
+      return this.foldFrames(dart.fn(_ => false, core.bool, [src__frame.Frame]), {terse: true});
+    }
+    foldFrames(predicate, opts) {
+      let terse = opts && 'terse' in opts ? opts.terse : false;
+      if (dart.notNull(terse)) {
+        let oldPredicate = predicate;
+        predicate = dart.fn(frame => {
+          if (dart.notNull(oldPredicate(frame))) return true;
+          if (dart.notNull(frame.isCore)) return true;
+          if (frame.package == 'stack_trace') return true;
+          if (!dart.notNull(frame.member[dartx.contains]('<async>'))) return false;
+          return frame.line == null;
+        }, core.bool, [src__frame.Frame]);
+      }
+      let newFrames = dart.list([], src__frame.Frame);
+      for (let frame of this.frames[dartx.reversed]) {
+        if (dart.is(frame, src__unparsed_frame.UnparsedFrame) || !dart.notNull(predicate(frame))) {
+          newFrames[dartx.add](frame);
+        } else if (dart.notNull(newFrames[dartx.isEmpty]) || !dart.notNull(predicate(newFrames[dartx.last]))) {
+          newFrames[dartx.add](new src__frame.Frame(frame.uri, frame.line, frame.column, frame.member));
+        }
+      }
+      if (dart.notNull(terse)) {
+        newFrames = newFrames[dartx.map](src__frame.Frame)(dart.fn(frame => {
+          if (dart.is(frame, src__unparsed_frame.UnparsedFrame) || !dart.notNull(predicate(frame))) return frame;
+          let library = frame.library[dartx.replaceAll](src__trace._terseRegExp, '');
+          return new src__frame.Frame(core.Uri.parse(library), null, null, frame.member);
+        }, src__frame.Frame, [src__frame.Frame]))[dartx.toList]();
+        if (dart.notNull(newFrames[dartx.length]) > 1 && dart.notNull(newFrames[dartx.first].isCore)) newFrames[dartx.removeAt](0);
+      }
+      return new src__trace.Trace(newFrames[dartx.reversed]);
+    }
+    toString() {
+      let longest = this.frames[dartx.map](core.int)(dart.fn(frame => frame.location[dartx.length], core.int, [src__frame.Frame]))[dartx.fold](core.int)(0, dart.gbind(math.max, core.int));
+      return this.frames[dartx.map](core.String)(dart.fn(frame => {
+        if (dart.is(frame, src__unparsed_frame.UnparsedFrame)) return `${frame}\n`;
+        return `${src__utils.padRight(frame.location, longest)}  ${frame.member}\n`;
+      }, core.String, [src__frame.Frame]))[dartx.join]();
+    }
+  };
+  dart.defineNamedConstructor(src__trace.Trace, 'parseVM');
+  dart.defineNamedConstructor(src__trace.Trace, 'parseV8');
+  dart.defineNamedConstructor(src__trace.Trace, 'parseJSCore');
+  dart.defineNamedConstructor(src__trace.Trace, 'parseIE');
+  dart.defineNamedConstructor(src__trace.Trace, 'parseFirefox');
+  dart.defineNamedConstructor(src__trace.Trace, 'parseSafari');
+  dart.defineNamedConstructor(src__trace.Trace, 'parseSafari6_1');
+  dart.defineNamedConstructor(src__trace.Trace, 'parseSafari6_0');
+  dart.defineNamedConstructor(src__trace.Trace, 'parseFriendly');
+  src__trace.Trace[dart.implements] = () => [core.StackTrace];
+  dart.setSignature(src__trace.Trace, {
+    constructors: () => ({
+      current: [src__trace.Trace, [], [core.int]],
+      from: [src__trace.Trace, [core.StackTrace]],
+      parse: [src__trace.Trace, [core.String]],
+      parseVM: [src__trace.Trace, [core.String]],
+      parseV8: [src__trace.Trace, [core.String]],
+      parseJSCore: [src__trace.Trace, [core.String]],
+      parseIE: [src__trace.Trace, [core.String]],
+      parseFirefox: [src__trace.Trace, [core.String]],
+      parseSafari: [src__trace.Trace, [core.String]],
+      parseSafari6_1: [src__trace.Trace, [core.String]],
+      parseSafari6_0: [src__trace.Trace, [core.String]],
+      parseFriendly: [src__trace.Trace, [core.String]],
+      Trace: [src__trace.Trace, [core.Iterable$(src__frame.Frame)]]
+    }),
+    methods: () => ({foldFrames: [src__trace.Trace, [dart.functionType(core.bool, [src__frame.Frame])], {terse: core.bool}]}),
+    statics: () => ({
+      format: [core.String, [core.StackTrace], {terse: core.bool}],
+      _parseVM: [core.List$(src__frame.Frame), [core.String]]
+    }),
+    names: ['format', '_parseVM']
+  });
+  src__chain.ChainHandler = dart.typedef('ChainHandler', () => dart.functionType(dart.void, [dart.dynamic, src__chain.Chain]));
+  src__chain.Chain = class Chain extends core.Object {
+    static get _currentSpec() {
+      return dart.as(async.Zone.current.get(dart.const(core.Symbol.new('stack_trace.stack_zone.spec'))), src__stack_zone_specification.StackZoneSpecification);
+    }
+    static capture(T) {
+      return (callback, opts) => {
+        let onError = opts && 'onError' in opts ? opts.onError : null;
+        let when = opts && 'when' in opts ? opts.when : true;
+        if (!dart.notNull(when)) {
+          let newOnError = null;
+          if (onError != null) {
+            newOnError = dart.fn((error, stackTrace) => {
+              dart.dcall(onError, error, src__chain.Chain.forTrace(dart.as(stackTrace, core.StackTrace)));
+            });
+          }
+          return async.runZoned(T)(callback, {onError: dart.as(newOnError, core.Function)});
+        }
+        let spec = new src__stack_zone_specification.StackZoneSpecification(onError);
+        return async.runZoned(T)(dart.fn(() => {
+          try {
+            return callback();
+          } catch (error) {
+            let stackTrace = dart.stackTrace(error);
+            return async.Zone.current.handleUncaughtError(T)(error, stackTrace);
+          }
+
+        }, T, []), {zoneSpecification: spec.toSpec(), zoneValues: dart.map([dart.const(core.Symbol.new('stack_trace.stack_zone.spec')), spec])});
+      };
+    }
+    static track(futureOrStream) {
+      return futureOrStream;
+    }
+    static current(level) {
+      if (level === void 0) level = 0;
+      if (src__chain.Chain._currentSpec != null) return src__chain.Chain._currentSpec.currentChain(dart.notNull(level) + 1);
+      return new src__chain.Chain(dart.list([src__trace.Trace.current(dart.notNull(level) + 1)], src__trace.Trace));
+    }
+    static forTrace(trace) {
+      if (dart.is(trace, src__chain.Chain)) return trace;
+      if (src__chain.Chain._currentSpec == null) return new src__chain.Chain(dart.list([src__trace.Trace.from(trace)], src__trace.Trace));
+      return src__chain.Chain._currentSpec.chainFor(trace);
+    }
+    static parse(chain) {
+      if (dart.notNull(chain[dartx.isEmpty])) return new src__chain.Chain(dart.list([], src__trace.Trace));
+      if (!dart.notNull(chain[dartx.contains](src__utils.chainGap))) return new src__chain.Chain(dart.list([src__trace.Trace.parse(chain)], src__trace.Trace));
+      return new src__chain.Chain(chain[dartx.split](src__utils.chainGap)[dartx.map](src__trace.Trace)(dart.fn(trace => new src__trace.Trace.parseFriendly(trace), src__trace.Trace, [core.String])));
+    }
+    Chain(traces) {
+      this.traces = new (collection.UnmodifiableListView$(src__trace.Trace))(traces[dartx.toList]());
+    }
+    get terse() {
+      return this.foldFrames(dart.fn(_ => false, core.bool, [src__frame.Frame]), {terse: true});
+    }
+    foldFrames(predicate, opts) {
+      let terse = opts && 'terse' in opts ? opts.terse : false;
+      let foldedTraces = this.traces[dartx.map](src__trace.Trace)(dart.fn(trace => trace.foldFrames(predicate, {terse: terse}), src__trace.Trace, [src__trace.Trace]));
+      let nonEmptyTraces = foldedTraces[dartx.where](dart.fn(trace => {
+        if (dart.notNull(trace.frames[dartx.length]) > 1) return true;
+        if (dart.notNull(trace.frames[dartx.isEmpty])) return false;
+        if (!dart.notNull(terse)) return false;
+        return trace.frames[dartx.single].line != null;
+      }, core.bool, [src__trace.Trace]));
+      if (dart.notNull(nonEmptyTraces[dartx.isEmpty]) && dart.notNull(foldedTraces[dartx.isNotEmpty])) {
+        return new src__chain.Chain(dart.list([foldedTraces[dartx.last]], src__trace.Trace));
+      }
+      return new src__chain.Chain(nonEmptyTraces);
+    }
+    toTrace() {
+      return new src__trace.Trace(this.traces[dartx.expand](src__frame.Frame)(dart.fn(trace => trace.frames, core.List$(src__frame.Frame), [src__trace.Trace])));
+    }
+    toString() {
+      let longest = this.traces[dartx.map](core.int)(dart.fn(trace => trace.frames[dartx.map](core.int)(dart.fn(frame => frame.location[dartx.length], core.int, [src__frame.Frame]))[dartx.fold](core.int)(0, dart.gbind(math.max, core.int)), core.int, [src__trace.Trace]))[dartx.fold](core.int)(0, dart.gbind(math.max, core.int));
+      return this.traces[dartx.map](core.String)(dart.fn(trace => trace.frames[dartx.map](core.String)(dart.fn(frame => `${src__utils.padRight(frame.location, longest)}  ${frame.member}\n`, core.String, [src__frame.Frame]))[dartx.join](), core.String, [src__trace.Trace]))[dartx.join](src__utils.chainGap);
+    }
+  };
+  src__chain.Chain[dart.implements] = () => [core.StackTrace];
+  dart.setSignature(src__chain.Chain, {
+    constructors: () => ({
+      current: [src__chain.Chain, [], [core.int]],
+      forTrace: [src__chain.Chain, [core.StackTrace]],
+      parse: [src__chain.Chain, [core.String]],
+      Chain: [src__chain.Chain, [core.Iterable$(src__trace.Trace)]]
+    }),
+    methods: () => ({
+      foldFrames: [src__chain.Chain, [dart.functionType(core.bool, [src__frame.Frame])], {terse: core.bool}],
+      toTrace: [src__trace.Trace, []]
+    }),
+    statics: () => ({
+      capture: [T => [T, [dart.functionType(T, [])], {onError: dart.functionType(dart.void, [dart.dynamic, src__chain.Chain]), when: core.bool}]],
+      track: [dart.dynamic, [dart.dynamic]]
+    }),
+    names: ['capture', 'track']
+  });
+  src__vm_trace.VMTrace = class VMTrace extends core.Object {
+    VMTrace(frames) {
+      this.frames = frames;
+    }
+    toString() {
+      let i = 1;
+      return this.frames[dartx.map](core.String)(dart.fn(frame => {
+        let number = src__utils.padRight(`#${i++}`, 8);
+        let member = frame.member[dartx.replaceAllMapped](core.RegExp.new("[^.]+\\.<async>"), dart.fn(match => `${match.get(1)}.<${match.get(1)}_async_body>`, core.String, [core.Match]))[dartx.replaceAll]("<fn>", "<anonymous closure>");
+        let line = frame.line == null ? 0 : frame.line;
+        let column = frame.column == null ? 0 : frame.column;
+        return `${number}${member} (${frame.uri}:${line}:${column})\n`;
+      }, core.String, [src__frame.Frame]))[dartx.join]();
+    }
+  };
+  src__vm_trace.VMTrace[dart.implements] = () => [core.StackTrace];
+  dart.setSignature(src__vm_trace.VMTrace, {
+    constructors: () => ({VMTrace: [src__vm_trace.VMTrace, [core.List$(src__frame.Frame)]]})
+  });
+  src__lazy_trace.TraceThunk = dart.typedef('TraceThunk', () => dart.functionType(src__trace.Trace, []));
+  const _thunk = Symbol('_thunk');
+  const _inner = Symbol('_inner');
+  const _trace = Symbol('_trace');
+  src__lazy_trace.LazyTrace = class LazyTrace extends core.Object {
+    LazyTrace(thunk) {
+      this[_thunk] = thunk;
+      this[_inner] = null;
+    }
+    get [_trace]() {
+      if (this[_inner] == null) this[_inner] = this[_thunk]();
+      return this[_inner];
+    }
+    get frames() {
+      return this[_trace].frames;
+    }
+    get vmTrace() {
+      return this[_trace].vmTrace;
+    }
+    get terse() {
+      return new src__lazy_trace.LazyTrace(dart.fn(() => this[_trace].terse, src__trace.Trace, []));
+    }
+    foldFrames(predicate, opts) {
+      let terse = opts && 'terse' in opts ? opts.terse : false;
+      return new src__lazy_trace.LazyTrace(dart.fn(() => this[_trace].foldFrames(predicate, {terse: terse}), src__trace.Trace, []));
+    }
+    toString() {
+      return dart.toString(this[_trace]);
+    }
+    set frames(_) {
+      return dart.throw(new core.UnimplementedError());
+    }
+  };
+  src__lazy_trace.LazyTrace[dart.implements] = () => [src__trace.Trace];
+  dart.setSignature(src__lazy_trace.LazyTrace, {
+    constructors: () => ({LazyTrace: [src__lazy_trace.LazyTrace, [src__lazy_trace.TraceThunk]]}),
+    methods: () => ({foldFrames: [src__trace.Trace, [dart.functionType(core.bool, [src__frame.Frame])], {terse: core.bool}]})
+  });
+  src__utils.chainGap = '===== asynchronous gap ===========================\n';
+  src__utils.padRight = function(string, length) {
+    if (dart.notNull(string[dartx.length]) >= dart.notNull(length)) return string;
+    let result = new core.StringBuffer();
+    result.write(string);
+    for (let i = 0; i < dart.notNull(length) - dart.notNull(string[dartx.length]); i++) {
+      result.write(' ');
+    }
+    return result.toString();
+  };
+  dart.fn(src__utils.padRight, core.String, [core.String, core.int]);
+  dart.defineLazy(src__frame, {
+    get _vmFrame() {
+      return core.RegExp.new('^#\\d+\\s+(\\S.*) \\((.+?)((?::\\d+){0,2})\\)$');
+    }
+  });
+  dart.defineLazy(src__frame, {
+    get _v8Frame() {
+      return core.RegExp.new('^\\s*at (?:(\\S.*?)(?: \\[as [^\\]]+\\])? \\((.*)\\)|(.*))$');
+    }
+  });
+  dart.defineLazy(src__frame, {
+    get _v8UrlLocation() {
+      return core.RegExp.new('^(.*):(\\d+):(\\d+)|native$');
+    }
+  });
+  dart.defineLazy(src__frame, {
+    get _v8EvalLocation() {
+      return core.RegExp.new('^eval at (?:\\S.*?) \\((.*)\\)(?:, .*?:\\d+:\\d+)?$');
+    }
+  });
+  dart.defineLazy(src__frame, {
+    get _firefoxSafariFrame() {
+      return core.RegExp.new('^' + '(?:' + '([^@(/]*)' + '(?:\\(.*\\))?' + '((?:/[^/]*)*)' + '(?:\\(.*\\))?' + '@' + ')?' + '(.*?)' + ':' + '(\\d*)' + '(?::(\\d*))?' + '$');
+    }
+  });
+  dart.defineLazy(src__frame, {
+    get _friendlyFrame() {
+      return core.RegExp.new('^(\\S+)(?: (\\d+)(?::(\\d+))?)?\\s+([^\\d]\\S*)$');
+    }
+  });
+  dart.defineLazy(src__frame, {
+    get _asyncBody() {
+      return core.RegExp.new('<(<anonymous closure>|[^>]+)_async_body>');
+    }
+  });
+  dart.defineLazy(src__frame, {
+    get _initialDot() {
+      return core.RegExp.new("^\\.");
+    }
+  });
+  src__frame.Frame = class Frame extends core.Object {
+    get isCore() {
+      return this.uri.scheme == 'dart';
+    }
+    get library() {
+      if (this.uri.scheme == 'data') return "data:...";
+      return path$.prettyUri(this.uri);
+    }
+    get package() {
+      if (this.uri.scheme != 'package') return null;
+      return this.uri.path[dartx.split]('/')[dartx.first];
+    }
+    get location() {
+      if (this.line == null) return this.library;
+      if (this.column == null) return `${this.library} ${this.line}`;
+      return `${this.library} ${this.line}:${this.column}`;
+    }
+    static caller(level) {
+      if (level === void 0) level = 1;
+      if (dart.notNull(level) < 0) {
+        dart.throw(new core.ArgumentError("Argument [level] must be greater than or equal " + "to 0."));
+      }
+      return src__trace.Trace.current(dart.notNull(level) + 1).frames[dartx.first];
+    }
+    static parseVM(frame) {
+      return src__frame.Frame._catchFormatException(frame, dart.fn(() => {
+        if (frame == '...') {
+          return new src__frame.Frame(core.Uri.new(), null, null, '...');
+        }
+        let match = src__frame._vmFrame.firstMatch(frame);
+        if (match == null) return new src__unparsed_frame.UnparsedFrame(frame);
+        let member = match.get(1)[dartx.replaceAll](src__frame._asyncBody, "<async>")[dartx.replaceAll]("<anonymous closure>", "<fn>");
+        let uri = core.Uri.parse(match.get(2));
+        let lineAndColumn = match.get(3)[dartx.split](':');
+        let line = dart.notNull(lineAndColumn[dartx.length]) > 1 ? core.int.parse(lineAndColumn[dartx.get](1)) : null;
+        let column = dart.notNull(lineAndColumn[dartx.length]) > 2 ? core.int.parse(lineAndColumn[dartx.get](2)) : null;
+        return new src__frame.Frame(uri, line, column, member);
+      }, src__frame.Frame, []));
+    }
+    static parseV8(frame) {
+      return src__frame.Frame._catchFormatException(frame, dart.fn(() => {
+        let match = src__frame._v8Frame.firstMatch(frame);
+        if (match == null) return new src__unparsed_frame.UnparsedFrame(frame);
+        function parseLocation(location, member) {
+          let evalMatch = src__frame._v8EvalLocation.firstMatch(dart.as(location, core.String));
+          while (evalMatch != null) {
+            location = evalMatch.get(1);
+            evalMatch = src__frame._v8EvalLocation.firstMatch(dart.as(location, core.String));
+          }
+          if (dart.equals(location, 'native')) {
+            return new src__frame.Frame(core.Uri.parse('native'), null, null, dart.as(member, core.String));
+          }
+          let urlMatch = src__frame._v8UrlLocation.firstMatch(dart.as(location, core.String));
+          if (urlMatch == null) return new src__unparsed_frame.UnparsedFrame(frame);
+          return new src__frame.Frame(src__frame.Frame._uriOrPathToUri(urlMatch.get(1)), core.int.parse(urlMatch.get(2)), core.int.parse(urlMatch.get(3)), dart.as(member, core.String));
+        }
+        dart.fn(parseLocation);
+        if (match.get(2) != null) {
+          return dart.as(parseLocation(match.get(2), match.get(1)[dartx.replaceAll]("<anonymous>", "<fn>")[dartx.replaceAll]("Anonymous function", "<fn>")), src__frame.Frame);
+        } else {
+          return dart.as(parseLocation(match.get(3), "<fn>"), src__frame.Frame);
+        }
+      }, src__frame.Frame, []));
+    }
+    static parseJSCore(frame) {
+      return src__frame.Frame.parseV8(frame);
+    }
+    static parseIE(frame) {
+      return src__frame.Frame.parseV8(frame);
+    }
+    static parseFirefox(frame) {
+      return src__frame.Frame._catchFormatException(frame, dart.fn(() => {
+        let match = src__frame._firefoxSafariFrame.firstMatch(frame);
+        if (match == null) return new src__unparsed_frame.UnparsedFrame(frame);
+        let uri = src__frame.Frame._uriOrPathToUri(match.get(3));
+        let member = null;
+        if (match.get(1) != null) {
+          member = match.get(1);
+          member = dart.dsend(member, '+', core.List.filled('/'[dartx.allMatches](match.get(2))[dartx.length], ".<fn>")[dartx.join]());
+          if (dart.equals(member, '')) member = '<fn>';
+          member = dart.dsend(member, 'replaceFirst', src__frame._initialDot, '');
+        } else {
+          member = '<fn>';
+        }
+        let line = match.get(4) == '' ? null : core.int.parse(match.get(4));
+        let column = match.get(5) == null || match.get(5) == '' ? null : core.int.parse(match.get(5));
+        return new src__frame.Frame(uri, line, column, dart.as(member, core.String));
+      }, src__frame.Frame, []));
+    }
+    static parseSafari6_0(frame) {
+      return src__frame.Frame.parseFirefox(frame);
+    }
+    static parseSafari6_1(frame) {
+      return src__frame.Frame.parseFirefox(frame);
+    }
+    static parseSafari(frame) {
+      return src__frame.Frame.parseFirefox(frame);
+    }
+    static parseFriendly(frame) {
+      return src__frame.Frame._catchFormatException(frame, dart.fn(() => {
+        let match = src__frame._friendlyFrame.firstMatch(frame);
+        if (match == null) {
+          dart.throw(new core.FormatException(`Couldn't parse package:stack_trace stack trace line '${frame}'.`));
+        }
+        let uri = core.Uri.parse(match.get(1));
+        if (uri.scheme == '') {
+          uri = path$.toUri(path$.absolute(path$.fromUri(uri)));
+        }
+        let line = match.get(2) == null ? null : core.int.parse(match.get(2));
+        let column = match.get(3) == null ? null : core.int.parse(match.get(3));
+        return new src__frame.Frame(uri, line, column, match.get(4));
+      }, src__frame.Frame, []));
+    }
+    static _uriOrPathToUri(uriOrPath) {
+      if (dart.notNull(uriOrPath[dartx.contains](src__frame.Frame._uriRegExp))) {
+        return core.Uri.parse(uriOrPath);
+      } else if (dart.notNull(uriOrPath[dartx.contains](src__frame.Frame._windowsRegExp))) {
+        return core.Uri.file(uriOrPath, {windows: true});
+      } else if (dart.notNull(uriOrPath[dartx.startsWith]('/'))) {
+        return core.Uri.file(uriOrPath, {windows: false});
+      }
+      if (dart.notNull(uriOrPath[dartx.contains]('\\'))) return path$.windows.toUri(uriOrPath);
+      return core.Uri.parse(uriOrPath);
+    }
+    static _catchFormatException(text, body) {
+      try {
+        return body();
+      } catch (_) {
+        if (dart.is(_, core.FormatException)) {
+          return new src__unparsed_frame.UnparsedFrame(text);
+        } else
+          throw _;
+      }
+
+    }
+    Frame(uri, line, column, member) {
+      this.uri = uri;
+      this.line = line;
+      this.column = column;
+      this.member = member;
+    }
+    toString() {
+      return `${this.location} in ${this.member}`;
+    }
+  };
+  dart.setSignature(src__frame.Frame, {
+    constructors: () => ({
+      caller: [src__frame.Frame, [], [core.int]],
+      parseVM: [src__frame.Frame, [core.String]],
+      parseV8: [src__frame.Frame, [core.String]],
+      parseJSCore: [src__frame.Frame, [core.String]],
+      parseIE: [src__frame.Frame, [core.String]],
+      parseFirefox: [src__frame.Frame, [core.String]],
+      parseSafari6_0: [src__frame.Frame, [core.String]],
+      parseSafari6_1: [src__frame.Frame, [core.String]],
+      parseSafari: [src__frame.Frame, [core.String]],
+      parseFriendly: [src__frame.Frame, [core.String]],
+      Frame: [src__frame.Frame, [core.Uri, core.int, core.int, core.String]]
+    }),
+    statics: () => ({
+      _uriOrPathToUri: [core.Uri, [core.String]],
+      _catchFormatException: [src__frame.Frame, [core.String, dart.functionType(src__frame.Frame, [])]]
+    }),
+    names: ['_uriOrPathToUri', '_catchFormatException']
+  });
+  dart.defineLazy(src__frame.Frame, {
+    get _uriRegExp() {
+      return core.RegExp.new('^[a-zA-Z][-+.a-zA-Z\\d]*://');
+    },
+    get _windowsRegExp() {
+      return core.RegExp.new('^([a-zA-Z]:[\\\\/]|\\\\\\\\)');
+    }
+  });
+  src__stack_zone_specification._ChainHandler = dart.typedef('_ChainHandler', () => dart.functionType(dart.void, [dart.dynamic, src__chain.Chain]));
+  const _chains = Symbol('_chains');
+  const _onError = Symbol('_onError');
+  const _currentNode = Symbol('_currentNode');
+  const _createNode = Symbol('_createNode');
+  const _run = Symbol('_run');
+  src__stack_zone_specification.StackZoneSpecification = class StackZoneSpecification extends core.Object {
+    StackZoneSpecification(onError) {
+      if (onError === void 0) onError = null;
+      this[_chains] = new (core.Expando$(src__stack_zone_specification._Node))("stack chains");
+      this[_onError] = onError;
+      this[_currentNode] = null;
+    }
+    toSpec() {
+      return async.ZoneSpecification.new({handleUncaughtError: dart.bind(this, 'handleUncaughtError'), registerCallback: dart.bind(this, 'registerCallback'), registerUnaryCallback: dart.bind(this, 'registerUnaryCallback'), registerBinaryCallback: dart.bind(this, 'registerBinaryCallback'), errorCallback: dart.bind(this, 'errorCallback')});
+    }
+    currentChain(level) {
+      if (level === void 0) level = 0;
+      return this[_createNode](dart.notNull(level) + 1).toChain();
+    }
+    chainFor(trace) {
+      if (dart.is(trace, src__chain.Chain)) return trace;
+      let previous = trace == null ? null : this[_chains].get(trace);
+      return new src__stack_zone_specification._Node(trace, previous).toChain();
+    }
+    trackFuture(future, level) {
+      if (level === void 0) level = 0;
+      let completer = async.Completer.sync();
+      let node = this[_createNode](dart.notNull(level) + 1);
+      future.then(dart.dynamic)(dart.bind(completer, 'complete')).catchError(dart.fn((e, stackTrace) => {
+        if (stackTrace == null) stackTrace = src__trace.Trace.current();
+        if (!dart.is(stackTrace, src__chain.Chain) && this[_chains].get(stackTrace) == null) {
+          this[_chains].set(stackTrace, node);
+        }
+        completer.completeError(e, dart.as(stackTrace, core.StackTrace));
+      }));
+      return completer.future;
+    }
+    trackStream(stream, level) {
+      if (level === void 0) level = 0;
+      let node = this[_createNode](dart.notNull(level) + 1);
+      return stream.transform(dart.dynamic)(async.StreamTransformer.fromHandlers({handleError: dart.fn((error, stackTrace, sink) => {
+          if (stackTrace == null) stackTrace = src__trace.Trace.current();
+          if (!dart.is(stackTrace, src__chain.Chain) && this[_chains].get(stackTrace) == null) {
+            this[_chains].set(stackTrace, node);
+          }
+          sink.addError(error, stackTrace);
+        }, dart.void, [core.Object, core.StackTrace, async.EventSink])}));
+    }
+    registerCallback(self, parent, zone, f) {
+      if (f == null) return parent.registerCallback(dart.dynamic)(zone, null);
+      let node = this[_createNode](1);
+      return parent.registerCallback(dart.dynamic)(zone, dart.fn(() => this[_run](f, node)));
+    }
+    registerUnaryCallback(self, parent, zone, f) {
+      if (f == null) return parent.registerUnaryCallback(dart.dynamic, dart.dynamic)(zone, null);
+      let node = this[_createNode](1);
+      return parent.registerUnaryCallback(dart.dynamic, dart.dynamic)(zone, dart.fn(arg => this[_run](dart.fn(() => dart.dcall(f, arg)), node)));
+    }
+    registerBinaryCallback(self, parent, zone, f) {
+      if (f == null) return parent.registerBinaryCallback(dart.dynamic, dart.dynamic, dart.dynamic)(zone, null);
+      let node = this[_createNode](1);
+      return parent.registerBinaryCallback(dart.dynamic, dart.dynamic, dart.dynamic)(zone, dart.fn((arg1, arg2) => this[_run](dart.fn(() => dart.dcall(f, arg1, arg2)), node)));
+    }
+    handleUncaughtError(self, parent, zone, error, stackTrace) {
+      let stackChain = this.chainFor(stackTrace);
+      if (this[_onError] == null) {
+        return parent.handleUncaughtError(dart.dynamic)(zone, error, stackChain);
+      }
+      try {
+        return parent.runBinary(dart.dynamic, dart.dynamic, src__chain.Chain)(zone, this[_onError], error, stackChain);
+      } catch (newError) {
+        let newStackTrace = dart.stackTrace(newError);
+        if (core.identical(newError, error)) {
+          return parent.handleUncaughtError(dart.dynamic)(zone, error, stackChain);
+        } else {
+          return parent.handleUncaughtError(dart.dynamic)(zone, newError, newStackTrace);
+        }
+      }
+
+    }
+    errorCallback(self, parent, zone, error, stackTrace) {
+      if (stackTrace == null) {
+        stackTrace = this[_createNode](2).toChain();
+      } else {
+        if (this[_chains].get(stackTrace) == null) this[_chains].set(stackTrace, this[_createNode](2));
+      }
+      let asyncError = parent.errorCallback(zone, error, stackTrace);
+      return asyncError == null ? new async.AsyncError(error, stackTrace) : asyncError;
+    }
+    [_createNode](level) {
+      if (level === void 0) level = 0;
+      return new src__stack_zone_specification._Node(src__trace.Trace.current(dart.notNull(level) + 1), this[_currentNode]);
+    }
+    [_run](f, node) {
+      let previousNode = this[_currentNode];
+      this[_currentNode] = node;
+      try {
+        return dart.dcall(f);
+      } catch (e) {
+        let stackTrace = dart.stackTrace(e);
+        this[_chains].set(stackTrace, node);
+        throw e;
+      }
+ finally {
+        this[_currentNode] = previousNode;
+      }
+    }
+  };
+  dart.setSignature(src__stack_zone_specification.StackZoneSpecification, {
+    constructors: () => ({StackZoneSpecification: [src__stack_zone_specification.StackZoneSpecification, [], [src__stack_zone_specification._ChainHandler]]}),
+    methods: () => ({
+      toSpec: [async.ZoneSpecification, []],
+      currentChain: [src__chain.Chain, [], [core.int]],
+      chainFor: [src__chain.Chain, [core.StackTrace]],
+      trackFuture: [async.Future, [async.Future], [core.int]],
+      trackStream: [async.Stream, [async.Stream], [core.int]],
+      registerCallback: [async.ZoneCallback, [async.Zone, async.ZoneDelegate, async.Zone, core.Function]],
+      registerUnaryCallback: [async.ZoneUnaryCallback, [async.Zone, async.ZoneDelegate, async.Zone, core.Function]],
+      registerBinaryCallback: [async.ZoneBinaryCallback, [async.Zone, async.ZoneDelegate, async.Zone, core.Function]],
+      handleUncaughtError: [dart.dynamic, [async.Zone, async.ZoneDelegate, async.Zone, dart.dynamic, core.StackTrace]],
+      errorCallback: [async.AsyncError, [async.Zone, async.ZoneDelegate, async.Zone, core.Object, core.StackTrace]],
+      [_createNode]: [src__stack_zone_specification._Node, [], [core.int]],
+      [_run]: [dart.dynamic, [core.Function, src__stack_zone_specification._Node]]
+    })
+  });
+  src__stack_zone_specification._Node = class _Node extends core.Object {
+    _Node(trace, previous) {
+      if (previous === void 0) previous = null;
+      this.previous = previous;
+      this.trace = trace == null ? src__trace.Trace.current() : src__trace.Trace.from(trace);
+    }
+    toChain() {
+      let nodes = dart.list([], src__trace.Trace);
+      let node = this;
+      while (node != null) {
+        nodes[dartx.add](node.trace);
+        node = node.previous;
+      }
+      return new src__chain.Chain(nodes);
+    }
+  };
+  dart.setSignature(src__stack_zone_specification._Node, {
+    constructors: () => ({_Node: [src__stack_zone_specification._Node, [core.StackTrace], [src__stack_zone_specification._Node]]}),
+    methods: () => ({toChain: [src__chain.Chain, []]})
+  });
+  src__unparsed_frame.UnparsedFrame = class UnparsedFrame extends core.Object {
+    UnparsedFrame(member) {
+      this.uri = core.Uri.new({path: "unparsed"});
+      this.member = member;
+      this.line = null;
+      this.column = null;
+      this.isCore = false;
+      this.library = "unparsed";
+      this.package = null;
+      this.location = "unparsed";
+    }
+    toString() {
+      return this.member;
+    }
+  };
+  src__unparsed_frame.UnparsedFrame[dart.implements] = () => [src__frame.Frame];
+  dart.setSignature(src__unparsed_frame.UnparsedFrame, {
+    constructors: () => ({UnparsedFrame: [src__unparsed_frame.UnparsedFrame, [core.String]]})
+  });
+  stack_trace.ChainHandler = src__chain.ChainHandler;
+  stack_trace.Chain = src__chain.Chain;
+  stack_trace.Frame = src__frame.Frame;
+  stack_trace.Trace = src__trace.Trace;
+  stack_trace.UnparsedFrame = src__unparsed_frame.UnparsedFrame;
+  // Exports:
+  exports.src__trace = src__trace;
+  exports.src__chain = src__chain;
+  exports.src__vm_trace = src__vm_trace;
+  exports.src__lazy_trace = src__lazy_trace;
+  exports.src__utils = src__utils;
+  exports.src__frame = src__frame;
+  exports.src__stack_zone_specification = src__stack_zone_specification;
+  exports.src__unparsed_frame = src__unparsed_frame;
+  exports.stack_trace = stack_trace;
+});