Fixes #254 - Better stacktrace support

lib/runtime/dart/_isolate_helper.js

 dart_library.library('dart/_isolate_helper', null, /* Imports */[
   "dart_runtime/dart",
   'dart/core',
   'dart/_interceptors',
   'dart/_js_helper',
   'dart/isolate',
   'dart/_foreign_helper',
   'dart/collection',
   'dart/async'
 ], /* Lazy imports */[
@@ skipping 57 matching lines @@
         return this.serializeWorkerSendPort(dart.as(x, _WorkerSendPort));
       if (dart.is(x, core.Function))
         return this.serializeClosure(dart.as(x, core.Function));
       return this.serializeDartObject(x);
     }
     unsupported(x, message) {
       if (message === void 0)
         message = null;
       if (message == null)
         message = "Can't transmit:";
-      throw new core.UnsupportedError(`${message} ${x}`);
+      dart.throw(new core.UnsupportedError(`${message} ${x}`));
     }
     makeRef(serializationId) {
       return ["ref", serializationId];
     }
     isPrimitive(x) {
       return x == null || typeof x == 'string' || dart.is(x, core.num) || typeof x == 'boolean';
     }
     serializePrimitive(primitive) {
       return primitive;
     }
@@ skipping 104 matching lines @@
   class _Deserializer extends core.Object {
     _Deserializer(opts) {
       let adjustSendPorts = opts && 'adjustSendPorts' in opts ? opts.adjustSendPorts : true;
       this.deserializedObjects = core.List.new();
       this[_adjustSendPorts] = dart.as(adjustSendPorts, core.bool);
     }
     deserialize(x) {
       if (dart.notNull(this.isPrimitive(x)))
         return this.deserializePrimitive(x);
       if (!dart.is(x, _interceptors.JSArray))
-        throw new core.ArgumentError(`Bad serialized message: ${x}`);
+        dart.throw(new core.ArgumentError(`Bad serialized message: ${x}`));
       switch (dart.dload(x, 'first')) {
         case "ref":
         {
           return this.deserializeRef(x);
         }
         case "buffer":
         {
           return this.deserializeByteBuffer(x);
         }
         case "typed":
@@ skipping 35 matching lines @@
         case "function":
         {
           return this.deserializeClosure(x);
         }
         case "dart":
         {
           return this.deserializeDartObject(x);
         }
         default:
         {
-          throw `couldn't deserialize: ${x}`;
+          dart.throw(`couldn't deserialize: ${x}`);
         }
       }
     }
     isPrimitive(x) {
       return x == null || typeof x == 'string' || dart.is(x, core.num) || typeof x == 'boolean';
     }
     deserializePrimitive(x) {
       return x;
     }
     deserializeRef(x) {
@@ skipping 158 matching lines @@
   dart.fn(isWorker, core.bool, []);
   function _currentIsolate() {
     return exports._globalState.currentContext;
   }
   dart.fn(_currentIsolate, () => dart.definiteFunctionType(_IsolateContext, []));
   function startRootIsolate(entry, args) {
     args = args;
     if (args == null)
       args = [];
     if (!dart.is(args, core.List)) {
-      throw new core.ArgumentError(`Arguments to main must be a List: ${args}`);
+      dart.throw(new core.ArgumentError(`Arguments to main must be a List: ${args}`));
     }
     exports._globalState = new _Manager(dart.as(entry, core.Function));
     if (dart.notNull(exports._globalState.isWorker))
       return;
     let rootContext = new _IsolateContext();
     exports._globalState.rootContext = rootContext;
     exports._globalState.currentContext = rootContext;
     if (dart.is(entry, _MainFunctionArgs)) {
       rootContext.eval(dart.fn(() => {
         dart.dcall(entry, args);
@@ skipping 301 matching lines @@
           break;
         }
         default:
       }
     }
     lookup(portId) {
       return this.ports.get(portId);
     }
     [_addRegistration](portId, port) {
       if (dart.notNull(this.ports.containsKey(portId))) {
-        throw core.Exception.new("Registry: ports must be registered only once.");
+        dart.throw(core.Exception.new("Registry: ports must be registered only once."));
       }
       this.ports.set(portId, port);
     }
     register(portId, port) {
       this[_addRegistration](portId, port);
       this[_updateGlobalState]();
     }
     registerWeak(portId, port) {
       this.weakPorts.add(portId);
       this[_addRegistration](portId, port);
@@ skipping 67 matching lines @@
     prequeue(event) {
       this.events.addFirst(event);
     }
     dequeue() {
       if (dart.notNull(this.events.isEmpty))
         return null;
       return this.events.removeFirst();
     }
     checkOpenReceivePortsFromCommandLine() {
       if (exports._globalState.rootContext != null && dart.notNull(exports._globalState.isolates.containsKey(exports._globalState.rootContext.id)) && dart.notNull(exports._globalState.fromCommandLine) && dart.notNull(exports._globalState.rootContext.ports.isEmpty)) {
-        throw core.Exception.new("Program exited with open ReceivePorts.");
+        dart.throw(core.Exception.new("Program exited with open ReceivePorts."));
       }
     }
     runIteration() {
       let event = this.dequeue();
       if (event == null) {
         this.checkOpenReceivePortsFromCommandLine();
         exports._globalState.maybeCloseWorker();
         return false;
       }
       event.process();
@@ skipping 106 matching lines @@
       if (stack == null) {
         stack = (function() {
           try {
             throw new Error();
           } catch (e) {
             return e.stack;
           }
 
         })();
         if (stack == null)
-          throw new core.UnsupportedError('No stack trace');
+          dart.throw(new core.UnsupportedError('No stack trace'));
       }
       let pattern = null, matches = null;
       pattern = new RegExp("^ *at [^(]*\\((.*):[0-9]*:[0-9]*\\)$", "m");
       matches = stack.match(pattern);
       if (matches != null)
         return matches[1];
       pattern = new RegExp("^[^@]*@(.*):[0-9]*$", "m");
       matches = stack.match(pattern);
       if (matches != null)
         return matches[1];
-      throw new core.UnsupportedError(`Cannot extract URI from "${stack}"`);
+      dart.throw(new core.UnsupportedError(`Cannot extract URI from "${stack}"`));
     }
     static _getEventData(e) {
       return e.data;
     }
     static _processWorkerMessage(sender, e) {
       let msg = _deserializeMessage(IsolateNatives._getEventData(e));
       switch (dart.dindex(msg, 'command')) {
         case 'start':
         {
           exports._globalState.currentManagerId = dart.as(dart.dindex(msg, 'id'), core.int);
@@ skipping 43 matching lines @@
         {
           if (dart.notNull(exports._globalState.isWorker)) {
             exports._globalState.mainManager.postMessage(_serializeMessage(dart.map({command: 'print', msg: msg})));
           } else {
             core.print(dart.dindex(msg, 'msg'));
           }
           break;
         }
         case 'error':
         {
-          throw dart.dindex(msg, 'msg');
+          dart.throw(dart.dindex(msg, 'msg'));
         }
       }
     }
     static handleSpawnWorkerRequest(msg) {
       let replyPort = dart.dindex(msg, 'replyPort');
       IsolateNatives.spawn(dart.as(dart.dindex(msg, 'functionName'), core.String), dart.as(dart.dindex(msg, 'uri'), core.String), dart.as(dart.dindex(msg, 'args'), core.List$(core.String)), dart.dindex(msg, 'msg'), false, dart.as(dart.dindex(msg, 'isSpawnUri'), core.bool), dart.as(dart.dindex(msg, 'startPaused'), core.bool)).then(dart.fn(msg => {
         dart.dsend(replyPort, 'send', msg);
       }), {onError: dart.fn(errorMessage => {
           dart.dsend(replyPort, 'send', [_SPAWN_FAILED_SIGNAL, errorMessage]);
         }, dart.dynamic, [core.String])});
     }
     static _log(msg) {
       if (dart.notNull(exports._globalState.isWorker)) {
         exports._globalState.mainManager.postMessage(_serializeMessage(dart.map({command: 'log', msg: msg})));
       } else {
         try {
           IsolateNatives._consoleLog(msg);
         } catch (e) {
           let trace = dart.stackTrace(e);
-          throw core.Exception.new(trace);
+          dart.throw(core.Exception.new(trace));
         }
 
       }
     }
     static _consoleLog(msg) {
       self.console.log(msg);
     }
     static _getJSFunctionFromName(functionName) {
       let globalFunctionsContainer = _foreign_helper.JS_EMBEDDED_GLOBAL("", _js_embedded_names.GLOBAL_FUNCTIONS);
       return globalFunctionsContainer[functionName]();
     }
     static _getJSFunctionName(f) {
       return dart.as(f.$name, core.String);
     }
     static _allocate(ctor) {
       return new ctor();
     }
     static spawnFunction(topLevelFunction, message, startPaused) {
       IsolateNatives.enableSpawnWorker = true;
       let name = IsolateNatives._getJSFunctionName(topLevelFunction);
       if (name == null) {
-        throw new core.UnsupportedError("only top-level functions can be spawned.");
+        dart.throw(new core.UnsupportedError("only top-level functions can be spawned."));
       }
       let isLight = false;
       let isSpawnUri = false;
       return IsolateNatives.spawn(name, null, null, message, isLight, isSpawnUri, startPaused);
     }
     static spawnUri(uri, args, message, startPaused) {
       IsolateNatives.enableSpawnWorker = true;
       let isLight = false;
       let isSpawnUri = true;
       return IsolateNatives.spawn(null, dart.toString(uri), args, message, isLight, isSpawnUri, startPaused);
@@ skipping 24 matching lines @@
       if (args != null)
         args = core.List$(core.String).from(args);
       if (dart.notNull(exports._globalState.isWorker)) {
         exports._globalState.mainManager.postMessage(_serializeMessage(dart.map({command: 'spawn-worker', functionName: functionName, args: args, msg: message, uri: uri, isSpawnUri: isSpawnUri, startPaused: startPaused, replyPort: replyPort})));
       } else {
         IsolateNatives._spawnWorker(functionName, uri, args, message, isSpawnUri, startPaused, replyPort, onError);
       }
     }
     static _startNonWorker(functionName, uri, args, message, isSpawnUri, startPaused, replyPort) {
       if (uri != null) {
-        throw new core.UnsupportedError("Currently spawnUri is not supported without web workers.");
+        dart.throw(new core.UnsupportedError("Currently spawnUri is not supported without web workers."));
       }
       message = _clone(message);
       if (args != null)
         args = core.List$(core.String).from(args);
       exports._globalState.topEventLoop.enqueue(new _IsolateContext(), dart.fn(() => {
         let func = IsolateNatives._getJSFunctionFromName(functionName);
         IsolateNatives._startIsolate(dart.as(func, core.Function), args, message, isSpawnUri, startPaused, replyPort);
       }), 'nonworker start');
     }
     static get currentIsolate() {
@@ skipping 95 matching lines @@
       return new (core.Expando$(core.int))();
     }
   });
   let _checkReplyTo = Symbol('_checkReplyTo');
   class _BaseSendPort extends core.Object {
     _BaseSendPort(isolateId) {
       this[_isolateId] = isolateId;
     }
     [_checkReplyTo](replyTo) {
       if (replyTo != null && !dart.is(replyTo, _NativeJsSendPort) && !dart.is(replyTo, _WorkerSendPort)) {
-        throw core.Exception.new("SendPort.send: Illegal replyTo port type");
+        dart.throw(core.Exception.new("SendPort.send: Illegal replyTo port type"));
       }
     }
   }
   _BaseSendPort[dart.implements] = () => [isolate.SendPort];
   dart.setSignature(_BaseSendPort, {
     constructors: () => ({_BaseSendPort: [_BaseSendPort, [core.int]]}),
     methods: () => ({[_checkReplyTo]: [dart.void, [isolate.SendPort]]})
   });
   let _isClosed = Symbol('_isClosed');
   let _add = Symbol('_add');
@@ skipping 191 matching lines @@
         let internalCallback = (function() {
           this[_handle] = null;
           leaveJsAsync();
           callback();
         }).bind(this);
         dart.fn(internalCallback, dart.void, []);
         enterJsAsync();
         this[_handle] = self.setTimeout(internalCallback, milliseconds);
       } else {
         dart.assert(dart.notNull(milliseconds) > 0);
-        throw new core.UnsupportedError("Timer greater than 0.");
+        dart.throw(new core.UnsupportedError("Timer greater than 0."));
       }
     }
     periodic(milliseconds, callback) {
       this[_once] = false;
       this[_inEventLoop] = false;
       this[_handle] = null;
       if (dart.notNull(hasTimer())) {
         enterJsAsync();
         this[_handle] = self.setInterval(dart.fn(() => {
           callback(this);
         }), milliseconds);
       } else {
-        throw new core.UnsupportedError("Periodic timer.");
+        dart.throw(new core.UnsupportedError("Periodic timer."));
       }
     }
     cancel() {
       if (dart.notNull(hasTimer())) {
         if (dart.notNull(this[_inEventLoop])) {
-          throw new core.UnsupportedError("Timer in event loop cannot be canceled.");
+          dart.throw(new core.UnsupportedError("Timer in event loop cannot be canceled."));
         }
         if (this[_handle] == null)
           return;
         leaveJsAsync();
         if (dart.notNull(this[_once])) {
           self.clearTimeout(this[_handle]);
         } else {
           self.clearInterval(this[_handle]);
         }
         this[_handle] = null;
       } else {
-        throw new core.UnsupportedError("Canceling a timer.");
+        dart.throw(new core.UnsupportedError("Canceling a timer."));
       }
     }
     get isActive() {
       return this[_handle] != null;
     }
   }
   TimerImpl[dart.implements] = () => [async.Timer];
   dart.defineNamedConstructor(TimerImpl, 'periodic');
   dart.setSignature(TimerImpl, {
     constructors: () => ({
@@ skipping 47 matching lines @@
   exports.leaveJsAsync = leaveJsAsync;
   exports.isWorker = isWorker;
   exports.startRootIsolate = startRootIsolate;
   exports.IsolateNatives = IsolateNatives;
   exports.RawReceivePortImpl = RawReceivePortImpl;
   exports.ReceivePortImpl = ReceivePortImpl;
   exports.TimerImpl = TimerImpl;
   exports.hasTimer = hasTimer;
   exports.CapabilityImpl = CapabilityImpl;
 });