Fixes #254 - Better stacktrace support

lib/runtime/dart/convert.js

 dart_library.library('dart/convert', null, /* Imports */[
   "dart_runtime/dart",
   'dart/core',
   'dart/async',
   'dart/typed_data',
   'dart/_internal',
   'dart/collection'
 ], /* Lazy imports */[
 ], function(exports, dart, core, async, typed_data, _internal, collection) {
   'use strict';
@@ skipping 88 matching lines @@
   let Converter$ = dart.generic(function(S, T) {
     class Converter extends core.Object {
       Converter() {
       }
       fuse(other) {
         dart.as(other, Converter$(T, dart.dynamic));
         return new (_FusedConverter$(S, T, dart.dynamic))(this, other);
       }
       startChunkedConversion(sink) {
         dart.as(sink, core.Sink$(T));
-        throw new core.UnsupportedError(`This converter does not support chunked conversions: ${this}`);
+        dart.throw(new core.UnsupportedError(`This converter does not support chunked conversions: ${this}`));
       }
       bind(source) {
         dart.as(source, async.Stream$(S));
         return async.Stream$(T).eventTransformed(source, dart.fn(sink => new _ConverterStreamEventSink(this, sink), _ConverterStreamEventSink, [async.EventSink]));
       }
     }
     Converter[dart.implements] = () => [async.StreamTransformer$(S, T)];
     dart.setSignature(Converter, {
       constructors: () => ({Converter: [Converter$(S, T), []]}),
       methods: () => ({
@@ skipping 18 matching lines @@
         end = null;
       let stringLength = string[dartx.length];
       core.RangeError.checkValidRange(start, end, stringLength);
       if (end == null)
         end = stringLength;
       let length = dart.notNull(end) - dart.notNull(start);
       let result = typed_data.Uint8List.new(length);
       for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
         let codeUnit = string[dartx.codeUnitAt](dart.notNull(start) + dart.notNull(i));
         if ((dart.notNull(codeUnit) & ~dart.notNull(this[_subsetMask])) != 0) {
-          throw new core.ArgumentError("String contains invalid characters.");
+          dart.throw(new core.ArgumentError("String contains invalid characters."));
         }
         result[dartx.set](i, codeUnit);
       }
       return dart.as(result, core.List$(core.int));
     }
     startChunkedConversion(sink) {
       if (!dart.is(sink, ByteConversionSink)) {
         sink = ByteConversionSink.from(sink);
       }
       return new _UnicodeSubsetEncoderSink(this[_subsetMask], dart.as(sink, ByteConversionSink));
@@ skipping 45 matching lines @@
       this[_sink] = sink;
     }
     close() {
       this[_sink].close();
     }
     addSlice(source, start, end, isLast) {
       core.RangeError.checkValidRange(start, end, source[dartx.length]);
       for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
         let codeUnit = source[dartx.codeUnitAt](i);
         if ((dart.notNull(codeUnit) & ~dart.notNull(this[_subsetMask])) != 0) {
-          throw new core.ArgumentError(`Source contains invalid character with code point: ${codeUnit}.`);
+          dart.throw(new core.ArgumentError(`Source contains invalid character with code point: ${codeUnit}.`));
         }
       }
       this[_sink].add(source[dartx.codeUnits][dartx.sublist](start, end));
       if (dart.notNull(isLast)) {
         this.close();
       }
     }
   }
   dart.setSignature(_UnicodeSubsetEncoderSink, {
     constructors: () => ({_UnicodeSubsetEncoderSink: [_UnicodeSubsetEncoderSink, [core.int, ByteConversionSink]]}),
@@ skipping 16 matching lines @@
         end = null;
       let byteCount = bytes[dartx.length];
       core.RangeError.checkValidRange(start, end, byteCount);
       if (end == null)
         end = byteCount;
       let length = dart.notNull(end) - dart.notNull(start);
       for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
         let byte = bytes[dartx.get](i);
         if ((dart.notNull(byte) & ~dart.notNull(this[_subsetMask])) != 0) {
           if (!dart.notNull(this[_allowInvalid])) {
-            throw new core.FormatException(`Invalid value in input: ${byte}`);
+            dart.throw(new core.FormatException(`Invalid value in input: ${byte}`));
           }
           return this[_convertInvalid](bytes, start, end);
         }
       }
       return core.String.fromCharCodes(bytes, start, end);
     }
     [_convertInvalid](bytes, start, end) {
       let buffer = new core.StringBuffer();
       for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
         let value = bytes[dartx.get](i);
@@ skipping 125 matching lines @@
   class _SimpleAsciiDecoderSink extends ByteConversionSinkBase {
     _SimpleAsciiDecoderSink(sink) {
       this[_sink] = sink;
     }
     close() {
       this[_sink].close();
     }
     add(source) {
       for (let i = 0; dart.notNull(i) < dart.notNull(source[dartx.length]); i = dart.notNull(i) + 1) {
         if ((dart.notNull(source[dartx.get](i)) & ~dart.notNull(_ASCII_MASK)) != 0) {
-          throw new core.FormatException("Source contains non-ASCII bytes.");
+          dart.throw(new core.FormatException("Source contains non-ASCII bytes."));
         }
       }
       this[_sink].add(core.String.fromCharCodes(source));
     }
     addSlice(source, start, end, isLast) {
       let length = source[dartx.length];
       core.RangeError.checkValidRange(start, end, length);
       if (dart.notNull(start) < dart.notNull(end)) {
         if (start != 0 || end != length) {
           source = source[dartx.sublist](start, end);
@@ skipping 591 matching lines @@
   class _JsonEncoderSink extends ChunkedConversionSink$(core.Object) {
     _JsonEncoderSink(sink, toEncodable, indent) {
       this[_sink] = sink;
       this[_toEncodable$] = toEncodable;
       this[_indent] = indent;
       this[_isDone] = false;
       super.ChunkedConversionSink();
     }
     add(o) {
       if (dart.notNull(this[_isDone])) {
-        throw new core.StateError("Only one call to add allowed");
+        dart.throw(new core.StateError("Only one call to add allowed"));
       }
       this[_isDone] = true;
       let stringSink = this[_sink].asStringSink();
       _JsonStringStringifier.printOn(o, stringSink, dart.as(this[_toEncodable$], dart.functionType(dart.dynamic, [dart.dynamic])), this[_indent]);
       stringSink.close();
     }
     close() {}
   }
   dart.setSignature(_JsonEncoderSink, {
     constructors: () => ({_JsonEncoderSink: [_JsonEncoderSink, [StringConversionSink, core.Function, core.String]]}),
@@ skipping 10 matching lines @@
       this[_indent] = indent;
       this[_bufferSize] = bufferSize;
       this[_isDone] = false;
       super.ChunkedConversionSink();
     }
     [_addChunk](chunk, start, end) {
       this[_sink].addSlice(chunk, start, end, false);
     }
     add(object) {
       if (dart.notNull(this[_isDone])) {
-        throw new core.StateError("Only one call to add allowed");
+        dart.throw(new core.StateError("Only one call to add allowed"));
       }
       this[_isDone] = true;
       _JsonUtf8Stringifier.stringify(object, this[_indent], dart.as(this[_toEncodable$], dart.functionType(dart.dynamic, [core.Object])), this[_bufferSize], dart.bind(this, _addChunk));
       this[_sink].close();
     }
     close() {
       if (!dart.notNull(this[_isDone])) {
         this[_isDone] = true;
         this[_sink].close();
       }
@@ skipping 27 matching lines @@
   dart.setSignature(JsonDecoder, {
     constructors: () => ({JsonDecoder: [JsonDecoder, [], [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]]}),
     methods: () => ({
       convert: [dart.dynamic, [core.String]],
       startChunkedConversion: [StringConversionSink, [core.Sink$(core.Object)]],
       bind: [async.Stream$(core.Object), [async.Stream$(core.String)]]
     })
   });
   function _parseJson(source, reviver) {
     if (!(typeof source == 'string'))
-      throw new core.ArgumentError(source);
+      dart.throw(new core.ArgumentError(source));
     let parsed = null;
     try {
       parsed = JSON.parse(source);
     } catch (e) {
-      throw new core.FormatException(String(e));
+      dart.throw(new core.FormatException(String(e)));
     }
 
     if (reviver == null) {
       return _convertJsonToDartLazy(parsed);
     } else {
       return _convertJsonToDart(parsed, reviver);
     }
   }
   dart.fn(_parseJson, dart.dynamic, [core.String, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]);
   function _defaultToEncodable(object) {
@@ skipping 69 matching lines @@
       }
       if (offset == 0) {
         this.writeString(s);
       } else if (dart.notNull(offset) < dart.notNull(length)) {
         this.writeStringSlice(s, offset, length);
       }
     }
     [_checkCycle](object) {
       for (let i = 0; dart.notNull(i) < dart.notNull(this[_seen][dartx.length]); i = dart.notNull(i) + 1) {
         if (dart.notNull(core.identical(object, this[_seen][dartx.get](i)))) {
-          throw new JsonCyclicError(object);
+          dart.throw(new JsonCyclicError(object));
         }
       }
       this[_seen][dartx.add](object);
     }
     [_removeSeen](object) {
       dart.assert(!dart.notNull(this[_seen][dartx.isEmpty]));
       dart.assert(core.identical(this[_seen][dartx.last], object));
       this[_seen][dartx.removeLast]();
     }
     writeObject(object) {
       if (dart.notNull(this.writeJsonValue(object)))
         return;
       this[_checkCycle](object);
       try {
         let customJson = dart.dcall(this[_toEncodable$], object);
         if (!dart.notNull(this.writeJsonValue(customJson))) {
-          throw new JsonUnsupportedObjectError(object);
+          dart.throw(new JsonUnsupportedObjectError(object));
         }
         this[_removeSeen](object);
       } catch (e) {
-        throw new JsonUnsupportedObjectError(object, {cause: e});
+        dart.throw(new JsonUnsupportedObjectError(object, {cause: e}));
       }
 
     }
     writeJsonValue(object) {
       if (dart.is(object, core.num)) {
         if (!dart.notNull(dart.as(dart.dload(object, 'isFinite'), core.bool)))
           return false;
         this.writeNumber(dart.as(object, core.num));
         return true;
       } else if (dart.notNull(core.identical(object, true))) {
@@ skipping 419 matching lines @@
     [_addSliceToSink](source, start, end, isLast) {
       this[_sink].add(core.String.fromCharCodes(source, start, end));
       if (dart.notNull(isLast))
         this.close();
     }
     addSlice(source, start, end, isLast) {
       core.RangeError.checkValidRange(start, end, source[dartx.length]);
       for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
         let char = source[dartx.get](i);
         if (dart.notNull(char) > dart.notNull(_LATIN1_MASK) || dart.notNull(char) < 0) {
-          throw new core.FormatException("Source contains non-Latin-1 characters.");
+          dart.throw(new core.FormatException("Source contains non-Latin-1 characters."));
         }
       }
       if (dart.notNull(start) < dart.notNull(end)) {
         this[_addSliceToSink](source, start, end, isLast);
       }
       if (dart.notNull(isLast)) {
         this.close();
       }
     }
   }
@@ skipping 764 matching lines @@
     }
     get hasPartialInput() {
       return dart.notNull(this[_expectedUnits]) > 0;
     }
     close() {
       this.flush();
     }
     flush() {
       if (dart.notNull(this.hasPartialInput)) {
         if (!dart.notNull(this[_allowMalformed])) {
-          throw new core.FormatException("Unfinished UTF-8 octet sequence");
+          dart.throw(new core.FormatException("Unfinished UTF-8 octet sequence"));
         }
         this[_stringSink].writeCharCode(UNICODE_REPLACEMENT_CHARACTER_RUNE);
         this[_value] = 0;
         this[_expectedUnits] = 0;
         this[_extraUnits] = 0;
       }
     }
     convert(codeUnits, startIndex, endIndex) {
       let value = this[_value];
       let expectedUnits = this[_expectedUnits];
@@ skipping 24 matching lines @@
           multibyte:
             if (dart.notNull(expectedUnits) > 0) {
               do {
                 if (i == endIndex) {
                   break loop;
                 }
                 let unit = codeUnits[dartx.get](i);
                 if ((dart.notNull(unit) & 192) != 128) {
                   expectedUnits = 0;
                   if (!dart.notNull(this[_allowMalformed])) {
-                    throw new core.FormatException(`Bad UTF-8 encoding 0x${unit[dartx.toRadixString](16)}`);
+                    dart.throw(new core.FormatException(`Bad UTF-8 encoding 0x${unit[dartx.toRadixString](16)}`));
                   }
                   this[_isFirstCharacter] = false;
                   this[_stringSink].writeCharCode(UNICODE_REPLACEMENT_CHARACTER_RUNE);
                   break multibyte;
                 } else {
                   value = dart.notNull(value) << 6 | dart.notNull(unit) & 63;
                   expectedUnits = dart.notNull(expectedUnits) - 1;
                   i = dart.notNull(i) + 1;
                 }
               } while (dart.notNull(expectedUnits) > 0);
               if (dart.notNull(value) <= dart.notNull(_Utf8Decoder._LIMITS[dartx.get](dart.notNull(extraUnits) - 1))) {
                 if (!dart.notNull(this[_allowMalformed])) {
-                  throw new core.FormatException(`Overlong encoding of 0x${value[dartx.toRadixString](16)}`);
+                  dart.throw(new core.FormatException(`Overlong encoding of 0x${value[dartx.toRadixString](16)}`));
                 }
                 expectedUnits = extraUnits = 0;
                 value = UNICODE_REPLACEMENT_CHARACTER_RUNE;
               }
               if (dart.notNull(value) > dart.notNull(_FOUR_BYTE_LIMIT)) {
                 if (!dart.notNull(this[_allowMalformed])) {
-                  throw new core.FormatException("Character outside valid Unicode range: " + `0x${value[dartx.toRadixString](16)}`);
+                  dart.throw(new core.FormatException("Character outside valid Unicode range: " + `0x${value[dartx.toRadixString](16)}`));
                 }
                 value = UNICODE_REPLACEMENT_CHARACTER_RUNE;
               }
               if (!dart.notNull(this[_isFirstCharacter]) || value != UNICODE_BOM_CHARACTER_RUNE) {
                 this[_stringSink].writeCharCode(value);
               }
               this[_isFirstCharacter] = false;
             }
           while (dart.notNull(i) < dart.notNull(endIndex)) {
             let oneBytes = scanOneByteCharacters(codeUnits, i);
             if (dart.notNull(oneBytes) > 0) {
               this[_isFirstCharacter] = false;
               addSingleBytes(i, dart.notNull(i) + dart.notNull(oneBytes));
               i = dart.notNull(i) + dart.notNull(oneBytes);
               if (i == endIndex)
                 break;
             }
             let unit = codeUnits[dartx.get]((() => {
               let x = i;
               i = dart.notNull(x) + 1;
               return x;
             })());
             if (dart.notNull(unit) < 0) {
               if (!dart.notNull(this[_allowMalformed])) {
-                throw new core.FormatException(`Negative UTF-8 code unit: -0x${(-dart.notNull(unit))[dartx.toRadixString](16)}`);
+                dart.throw(new core.FormatException(`Negative UTF-8 code unit: -0x${(-dart.notNull(unit))[dartx.toRadixString](16)}`));
               }
               this[_stringSink].writeCharCode(UNICODE_REPLACEMENT_CHARACTER_RUNE);
             } else {
               dart.assert(dart.notNull(unit) > dart.notNull(_ONE_BYTE_LIMIT));
               if ((dart.notNull(unit) & 224) == 192) {
                 value = dart.notNull(unit) & 31;
                 expectedUnits = extraUnits = 1;
                 continue loop;
               }
               if ((dart.notNull(unit) & 240) == 224) {
                 value = dart.notNull(unit) & 15;
                 expectedUnits = extraUnits = 2;
                 continue loop;
               }
               if ((dart.notNull(unit) & 248) == 240 && dart.notNull(unit) < 245) {
                 value = dart.notNull(unit) & 7;
                 expectedUnits = extraUnits = 3;
                 continue loop;
               }
               if (!dart.notNull(this[_allowMalformed])) {
-                throw new core.FormatException(`Bad UTF-8 encoding 0x${unit[dartx.toRadixString](16)}`);
+                dart.throw(new core.FormatException(`Bad UTF-8 encoding 0x${unit[dartx.toRadixString](16)}`));
               }
               value = UNICODE_REPLACEMENT_CHARACTER_RUNE;
               expectedUnits = extraUnits = 0;
               this[_isFirstCharacter] = false;
               this[_stringSink].writeCharCode(value);
             }
           }
           break loop;
         }
       if (dart.notNull(expectedUnits) > 0) {
@@ skipping 167 matching lines @@
       let keys = this[_computeKeys]();
       for (let i = 0; dart.notNull(i) < dart.notNull(keys[dartx.length]); i = dart.notNull(i) + 1) {
         let key = keys[dartx.get](i);
         let value = _JsonMap._getProperty(this[_processed], key);
         if (dart.notNull(_JsonMap._isUnprocessed(value))) {
           value = _convertJsonToDartLazy(_JsonMap._getProperty(this[_original], key));
           _JsonMap._setProperty(this[_processed], key, value);
         }
         dart.dcall(f, key, value);
         if (!dart.notNull(core.identical(keys, this[_data]))) {
-          throw new core.ConcurrentModificationError(this);
+          dart.throw(new core.ConcurrentModificationError(this));
         }
       }
     }
     toString() {
       return collection.Maps.mapToString(this);
     }
     get [_isUpgraded]() {
       return this[_processed] == null;
     }
     get [_upgradedMap]() {
@@ skipping 155 matching lines @@
   exports.LineSplitter = LineSplitter;
   exports.StringConversionSink = StringConversionSink;
   exports.ClosableStringSink = ClosableStringSink;
   exports.UNICODE_REPLACEMENT_CHARACTER_RUNE = UNICODE_REPLACEMENT_CHARACTER_RUNE;
   exports.UNICODE_BOM_CHARACTER_RUNE = UNICODE_BOM_CHARACTER_RUNE;
   exports.Utf8Codec = Utf8Codec;
   exports.UTF8 = UTF8;
   exports.Utf8Encoder = Utf8Encoder;
   exports.Utf8Decoder = Utf8Decoder;
 });