fixes #193, factory constructors as static methods

lib/runtime/dart/convert.js

 var convert = dart.defineLibrary(convert, {});
 var core = dart.import(core);
 var async = dart.import(async);
 var typed_data = dart.import(typed_data);
 var _internal = dart.import(_internal);
 var collection = dart.import(collection);
 (function(exports, core, async, typed_data, _internal, collection) {
   'use strict';
   let Codec$ = dart.generic(function(S, T) {
     class Codec extends core.Object {
@@ skipping 89 matching lines @@
       fuse(other) {
         dart.as(other, Converter$(T, core.Object));
         return new (_FusedConverter$(S, T, core.Object))(this, other);
       }
       startChunkedConversion(sink) {
         dart.as(sink, core.Sink$(T));
         throw new core.UnsupportedError(`This converter does not support chunked conversions: ${this}`);
       }
       bind(source) {
         dart.as(source, async.Stream$(S));
-        return new (async.Stream$(T)).eventTransformed(source, dart.fn((sink => new _ConverterStreamEventSink(this, sink)).bind(this), _ConverterStreamEventSink, [async.EventSink]));
+        return async.Stream$(T).eventTransformed(source, dart.fn((sink => new _ConverterStreamEventSink(this, sink)).bind(this), _ConverterStreamEventSink, [async.EventSink]));
       }
     }
     Converter[dart.implements] = () => [async.StreamTransformer$(S, T)];
     dart.setSignature(Converter, {
       constructors: () => ({Converter: [Converter$(S, T), []]}),
       methods: () => ({
         fuse: [Converter$(S, core.Object), [Converter$(T, core.Object)]],
         startChunkedConversion: [ChunkedConversionSink, [core.Sink$(T)]],
         bind: [async.Stream$(T), [async.Stream$(S)]]
       })
@@ skipping 10 matching lines @@
     convert(string, start, end) {
       if (start === void 0)
         start = 0;
       if (end === void 0)
         end = null;
       let stringLength = string.length;
       core.RangeError.checkValidRange(start, end, stringLength);
       if (end == null)
         end = stringLength;
       let length = dart.notNull(end) - dart.notNull(start);
-      let result = new typed_data.Uint8List(length);
+      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.codeUnitAt(dart.notNull(start) + dart.notNull(i));
         if ((dart.notNull(codeUnit) & ~dart.notNull(this[_subsetMask])) != 0) {
           throw new core.ArgumentError("String contains invalid characters.");
         }
         result[core.$set](i, codeUnit);
       }
       return dart.as(result, core.List$(core.int));
     }
     startChunkedConversion(sink) {
       if (!dart.is(sink, ByteConversionSink)) {
-        sink = new ByteConversionSink.from(sink);
+        sink = ByteConversionSink.from(sink);
       }
       return new _UnicodeSubsetEncoderSink(this[_subsetMask], dart.as(sink, ByteConversionSink));
     }
     bind(stream) {
       return super.bind(stream);
     }
   }
   dart.setSignature(_UnicodeSubsetEncoder, {
     constructors: () => ({_UnicodeSubsetEncoder: [_UnicodeSubsetEncoder, [core.int]]}),
     methods: () => ({
@@ skipping 79 matching lines @@
       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[core.$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}`);
           }
           return this[_convertInvalid](bytes, start, end);
         }
       }
-      return new core.String.fromCharCodes(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[core.$get](i);
         if ((dart.notNull(value) & ~dart.notNull(this[_subsetMask])) != 0)
           value = 65533;
         buffer.writeCharCode(value);
       }
       return dart.toString(buffer);
@@ skipping 13 matching lines @@
   class AsciiDecoder extends _UnicodeSubsetDecoder {
     AsciiDecoder(opts) {
       let allowInvalid = opts && 'allowInvalid' in opts ? opts.allowInvalid : false;
       super._UnicodeSubsetDecoder(allowInvalid, _ASCII_MASK);
     }
     startChunkedConversion(sink) {
       let stringSink = null;
       if (dart.is(sink, StringConversionSink)) {
         stringSink = sink;
       } else {
-        stringSink = new StringConversionSink.from(sink);
+        stringSink = StringConversionSink.from(sink);
       }
       if (this[_allowInvalid]) {
         return new _ErrorHandlingAsciiDecoderSink(stringSink.asUtf8Sink(false));
       } else {
         return new _SimpleAsciiDecoderSink(stringSink);
       }
     }
   }
   dart.setSignature(AsciiDecoder, {
     constructors: () => ({AsciiDecoder: [AsciiDecoder, [], {allowInvalid: core.bool}]}),
     methods: () => ({startChunkedConversion: [ByteConversionSink, [core.Sink$(core.String)]]})
   });
   let ChunkedConversionSink$ = dart.generic(function(T) {
     class ChunkedConversionSink extends core.Object {
       ChunkedConversionSink() {
       }
-      withCallback(callback) {
+      static withCallback(callback) {
         return new _SimpleCallbackSink(callback);
       }
     }
     ChunkedConversionSink[dart.implements] = () => [core.Sink$(T)];
-    dart.defineNamedConstructor(ChunkedConversionSink, 'withCallback');
     dart.setSignature(ChunkedConversionSink, {
       constructors: () => ({
         ChunkedConversionSink: [ChunkedConversionSink$(T), []],
         withCallback: [ChunkedConversionSink$(T), [dart.functionType(dart.void, [core.List$(T)])]]
       })
     });
     return ChunkedConversionSink;
   });
   let ChunkedConversionSink = ChunkedConversionSink$();
   class ByteConversionSink extends ChunkedConversionSink$(core.List$(core.int)) {
     ByteConversionSink() {
       super.ChunkedConversionSink();
     }
-    withCallback(callback) {
+    static withCallback(callback) {
       return new _ByteCallbackSink(callback);
     }
-    from(sink) {
+    static from(sink) {
       return new _ByteAdapterSink(sink);
     }
   }
-  dart.defineNamedConstructor(ByteConversionSink, 'withCallback');
-  dart.defineNamedConstructor(ByteConversionSink, 'from');
   dart.setSignature(ByteConversionSink, {
     constructors: () => ({
       ByteConversionSink: [ByteConversionSink, []],
       withCallback: [ByteConversionSink, [dart.functionType(dart.void, [core.List$(core.int)])]],
       from: [ByteConversionSink, [core.Sink$(core.List$(core.int))]]
     })
   });
   class ByteConversionSinkBase extends ByteConversionSink {
     ByteConversionSinkBase() {
       super.ByteConversionSink();
@@ skipping 48 matching lines @@
     }
     close() {
       this[_sink].close();
     }
     add(source) {
       for (let i = 0; dart.notNull(i) < dart.notNull(source[core.$length]); i = dart.notNull(i) + 1) {
         if ((dart.notNull(source[core.$get](i)) & ~dart.notNull(_ASCII_MASK)) != 0) {
           throw new core.FormatException("Source contains non-ASCII bytes.");
         }
       }
-      this[_sink].add(new core.String.fromCharCodes(source));
+      this[_sink].add(core.String.fromCharCodes(source));
     }
     addSlice(source, start, end, isLast) {
       let length = source[core.$length];
       core.RangeError.checkValidRange(start, end, length);
       if (dart.notNull(start) < dart.notNull(end)) {
         if (start != 0 || end != length) {
           source = source[core.$sublist](start, end);
         }
         this.add(source);
       }
@@ skipping 24 matching lines @@
     methods: () => ({
       add: [dart.void, [core.List$(core.int)]],
       close: [dart.void, []]
     })
   });
   let _buffer = Symbol('_buffer');
   let _callback = Symbol('_callback');
   let _bufferIndex = Symbol('_bufferIndex');
   class _ByteCallbackSink extends ByteConversionSinkBase {
     _ByteCallbackSink(callback) {
-      this[_buffer] = new typed_data.Uint8List(_ByteCallbackSink._INITIAL_BUFFER_SIZE);
+      this[_buffer] = typed_data.Uint8List.new(_ByteCallbackSink._INITIAL_BUFFER_SIZE);
       this[_callback] = callback;
       this[_bufferIndex] = 0;
     }
     add(chunk) {
       let freeCount = dart.notNull(this[_buffer][core.$length]) - dart.notNull(this[_bufferIndex]);
       if (dart.notNull(chunk[core.$length]) > dart.notNull(freeCount)) {
         let oldLength = this[_buffer][core.$length];
         let newLength = dart.notNull(_ByteCallbackSink._roundToPowerOf2(dart.notNull(chunk[core.$length]) + dart.notNull(oldLength))) * 2;
-        let grown = new typed_data.Uint8List(newLength);
+        let grown = typed_data.Uint8List.new(newLength);
         grown[core.$setRange](0, this[_buffer][core.$length], this[_buffer]);
         this[_buffer] = grown;
       }
       this[_buffer][core.$setRange](this[_bufferIndex], dart.notNull(this[_bufferIndex]) + dart.notNull(chunk[core.$length]), chunk);
       this[_bufferIndex] = dart.notNull(this[_bufferIndex]) + dart.notNull(chunk[core.$length]);
     }
     static _roundToPowerOf2(v) {
       dart.assert(dart.notNull(v) > 0);
       v = dart.notNull(v) - 1;
       v = dart.notNull(v) | dart.notNull(v) >> 1;
@@ skipping 265 matching lines @@
             result = new core.StringBuffer(text.substring(start, i));
           result.write(replace);
         } else if (result != null) {
           result.write(ch);
         }
       }
       return result != null ? dart.toString(result) : null;
     }
     startChunkedConversion(sink) {
       if (!dart.is(sink, StringConversionSink)) {
-        sink = new StringConversionSink.from(sink);
+        sink = StringConversionSink.from(sink);
       }
       return new _HtmlEscapeSink(this, dart.as(sink, StringConversionSink));
     }
   }
   dart.setSignature(HtmlEscape, {
     constructors: () => ({HtmlEscape: [HtmlEscape, [], [HtmlEscapeMode]]}),
     methods: () => ({
       convert: [core.String, [core.String]],
       [_convert]: [core.String, [core.String, core.int, core.int]],
       startChunkedConversion: [StringConversionSink, [core.Sink$(core.String)]]
@@ skipping 125 matching lines @@
         toEncodable = null;
       this.indent = indent;
       this[_toEncodable$] = toEncodable;
       super.Converter();
     }
     convert(object) {
       return _JsonStringStringifier.stringify(object, dart.as(this[_toEncodable$], __CastType2), this.indent);
     }
     startChunkedConversion(sink) {
       if (!dart.is(sink, StringConversionSink)) {
-        sink = new StringConversionSink.from(sink);
+        sink = StringConversionSink.from(sink);
       } else if (dart.is(sink, _Utf8EncoderSink)) {
         return new _JsonUtf8EncoderSink(sink[_sink], this[_toEncodable$], JsonUtf8Encoder._utf8Encode(this.indent), JsonUtf8Encoder.DEFAULT_BUFFER_SIZE);
       }
       return new _JsonEncoderSink(dart.as(sink, StringConversionSink), this[_toEncodable$], this.indent);
     }
     bind(stream) {
       return super.bind(stream);
     }
     fuse(other) {
       if (dart.is(other, Utf8Encoder)) {
@@ skipping 27 matching lines @@
         bufferSize = JsonUtf8Encoder.DEFAULT_BUFFER_SIZE;
       this[_indent] = JsonUtf8Encoder._utf8Encode(indent);
       this[_toEncodable$] = toEncodable;
       this[_bufferSize] = bufferSize;
       super.Converter();
     }
     static _utf8Encode(string) {
       if (string == null)
         return null;
       if (string.isEmpty)
-        return new typed_data.Uint8List(0);
+        return typed_data.Uint8List.new(0);
       checkAscii: {
         for (let i = 0; dart.notNull(i) < dart.notNull(string.length); i = dart.notNull(i) + 1) {
           if (dart.notNull(string.codeUnitAt(i)) >= 128)
             break checkAscii;
         }
         return string.codeUnits;
       }
       return UTF8.encode(string);
     }
     convert(object) {
       let bytes = dart.setType([], core.List$(core.List$(core.int)));
       let addChunk = (chunk, start, end) => {
         if (dart.notNull(start) > 0 || dart.notNull(end) < dart.notNull(chunk[core.$length])) {
           let length = dart.notNull(end) - dart.notNull(start);
-          chunk = new typed_data.Uint8List.view(chunk.buffer, dart.notNull(chunk.offsetInBytes) + dart.notNull(start), length);
+          chunk = typed_data.Uint8List.view(chunk.buffer, dart.notNull(chunk.offsetInBytes) + dart.notNull(start), length);
         }
         bytes[core.$add](chunk);
       };
       dart.fn(addChunk, dart.void, [typed_data.Uint8List, core.int, core.int]);
       _JsonUtf8Stringifier.stringify(object, this[_indent], dart.as(this[_toEncodable$], dart.functionType(core.Object, [core.Object])), this[_bufferSize], addChunk);
       if (bytes[core.$length] == 1)
         return bytes[core.$get](0);
       let length = 0;
       for (let i = 0; dart.notNull(i) < dart.notNull(bytes[core.$length]); i = dart.notNull(i) + 1) {
         length = dart.notNull(length) + dart.notNull(bytes[core.$get](i)[core.$length]);
       }
-      let result = new typed_data.Uint8List(length);
+      let result = typed_data.Uint8List.new(length);
       for (let i = 0, offset = 0; dart.notNull(i) < dart.notNull(bytes[core.$length]); i = dart.notNull(i) + 1) {
         let byteList = bytes[core.$get](i);
         let end = dart.notNull(offset) + dart.notNull(byteList[core.$length]);
         result[core.$setRange](offset, end, byteList);
         offset = end;
       }
       return result;
     }
     startChunkedConversion(sink) {
       let byteSink = null;
       if (dart.is(sink, ByteConversionSink)) {
         byteSink = sink;
       } else {
-        byteSink = new ByteConversionSink.from(sink);
+        byteSink = ByteConversionSink.from(sink);
       }
       return new _JsonUtf8EncoderSink(byteSink, this[_toEncodable$], this[_indent], this[_bufferSize]);
     }
     bind(stream) {
       return super.bind(stream);
     }
     fuse(other) {
       return super.fuse(other);
     }
   }
@@ skipping 116 matching lines @@
   dart.fn(_parseJson, core.Object, [core.String, dart.functionType(core.Object, [dart.bottom, dart.bottom])]);
   function _defaultToEncodable(object) {
     return dart.dsend(object, 'toJson');
   }
   dart.fn(_defaultToEncodable, core.Object, [core.Object]);
   let _seen = Symbol('_seen');
   let _checkCycle = Symbol('_checkCycle');
   let _removeSeen = Symbol('_removeSeen');
   class _JsonStringifier extends core.Object {
     _JsonStringifier(_toEncodable) {
-      this[_seen] = new core.List();
+      this[_seen] = core.List.new();
       this[_toEncodable$] = _toEncodable != null ? _toEncodable : _defaultToEncodable;
     }
     static hexDigit(x) {
       return dart.notNull(x) < 10 ? 48 + dart.notNull(x) : 87 + dart.notNull(x);
     }
     writeStringContent(s) {
       let offset = 0;
       let length = s.length;
       for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
         let charCode = s.codeUnitAt(i);
@@ skipping 281 matching lines @@
     }
   }
   dart.setSignature(_JsonStringStringifierPretty, {
     constructors: () => ({_JsonStringStringifierPretty: [_JsonStringStringifierPretty, [core.StringSink, core.Function, core.String]]}),
     methods: () => ({writeIndentation: [dart.void, [core.int]]})
   });
   class _JsonUtf8Stringifier extends _JsonStringifier {
     _JsonUtf8Stringifier(toEncodable, bufferSize, addChunk) {
       this.addChunk = addChunk;
       this.bufferSize = bufferSize;
-      this.buffer = new typed_data.Uint8List(bufferSize);
+      this.buffer = typed_data.Uint8List.new(bufferSize);
       this.index = 0;
       super._JsonStringifier(dart.as(toEncodable, dart.functionType(core.Object, [core.Object])));
     }
     static stringify(object, indent, toEncodableFunction, bufferSize, addChunk) {
       let stringifier = null;
       if (indent != null) {
         stringifier = new _JsonUtf8StringifierPretty(toEncodableFunction, indent, bufferSize, addChunk);
       } else {
         stringifier = new _JsonUtf8Stringifier(toEncodableFunction, bufferSize, addChunk);
       }
@@ skipping 64 matching lines @@
       dart.assert(dart.notNull(charCode) <= 1114111);
       this.writeByte(240 | dart.notNull(charCode) >> 18);
       this.writeByte(128 | dart.notNull(charCode) >> 12 & 63);
       this.writeByte(128 | dart.notNull(charCode) >> 6 & 63);
       this.writeByte(128 | dart.notNull(charCode) & 63);
     }
     writeByte(byte) {
       dart.assert(dart.notNull(byte) <= 255);
       if (this.index == this.buffer[core.$length]) {
         dart.dcall(this.addChunk, this.buffer, 0, this.index);
-        this.buffer = new typed_data.Uint8List(this.bufferSize);
+        this.buffer = typed_data.Uint8List.new(this.bufferSize);
         this.index = 0;
       }
       this.buffer[core.$set]((() => {
         let x = this.index;
         this.index = dart.notNull(x) + 1;
         return x;
       }).bind(this)(), byte);
     }
   }
   dart.setSignature(_JsonUtf8Stringifier, {
@@ skipping 92 matching lines @@
   class Latin1Decoder extends _UnicodeSubsetDecoder {
     Latin1Decoder(opts) {
       let allowInvalid = opts && 'allowInvalid' in opts ? opts.allowInvalid : false;
       super._UnicodeSubsetDecoder(allowInvalid, _LATIN1_MASK);
     }
     startChunkedConversion(sink) {
       let stringSink = null;
       if (dart.is(sink, StringConversionSink)) {
         stringSink = sink;
       } else {
-        stringSink = new StringConversionSink.from(sink);
+        stringSink = StringConversionSink.from(sink);
       }
       if (!dart.notNull(this[_allowInvalid]))
         return new _Latin1DecoderSink(stringSink);
       return new _Latin1AllowInvalidDecoderSink(stringSink);
     }
   }
   dart.setSignature(Latin1Decoder, {
     constructors: () => ({Latin1Decoder: [Latin1Decoder, [], {allowInvalid: core.bool}]}),
     methods: () => ({startChunkedConversion: [ByteConversionSink, [core.Sink$(core.String)]]})
   });
   let _addSliceToSink = Symbol('_addSliceToSink');
   class _Latin1DecoderSink extends ByteConversionSinkBase {
     _Latin1DecoderSink(sink) {
       this[_sink] = sink;
     }
     close() {
       this[_sink].close();
     }
     add(source) {
       this.addSlice(source, 0, source[core.$length], false);
     }
     [_addSliceToSink](source, start, end, isLast) {
-      this[_sink].add(new core.String.fromCharCodes(source, start, end));
+      this[_sink].add(core.String.fromCharCodes(source, start, end));
       if (isLast)
         this.close();
     }
     addSlice(source, start, end, isLast) {
       core.RangeError.checkValidRange(start, end, source[core.$length]);
       for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
         let char = source[core.$get](i);
         if (dart.notNull(char) > dart.notNull(_LATIN1_MASK) || dart.notNull(char) < 0) {
           throw new core.FormatException("Source contains non-Latin-1 characters.");
         }
@@ skipping 38 matching lines @@
     }
   }
   dart.setSignature(_Latin1AllowInvalidDecoderSink, {
     constructors: () => ({_Latin1AllowInvalidDecoderSink: [_Latin1AllowInvalidDecoderSink, [StringConversionSink]]})
   });
   class LineSplitter extends Converter$(core.String, core.List$(core.String)) {
     LineSplitter() {
       super.Converter();
     }
     convert(data) {
-      let lines = new (core.List$(core.String))();
+      let lines = core.List$(core.String).new();
       _LineSplitterSink._addSlice(data, 0, data.length, true, dart.bind(lines, core.$add));
       return lines;
     }
     startChunkedConversion(sink) {
       if (!dart.is(sink, StringConversionSink)) {
-        sink = new StringConversionSink.from(dart.as(sink, core.Sink$(core.String)));
+        sink = StringConversionSink.from(dart.as(sink, core.Sink$(core.String)));
       }
       return new _LineSplitterSink(dart.as(sink, StringConversionSink));
     }
   }
   dart.setSignature(LineSplitter, {
     constructors: () => ({LineSplitter: [LineSplitter, []]}),
     methods: () => ({
       convert: [core.List$(core.String), [core.String]],
       startChunkedConversion: [StringConversionSink, [core.Sink]]
     })
@@ skipping 61 matching lines @@
     }),
     statics: () => ({_addSlice: [core.String, [core.String, core.int, core.int, core.bool, dart.functionType(dart.void, [core.String])]]}),
     names: ['_addSlice']
   });
   _LineSplitterSink._LF = 10;
   _LineSplitterSink._CR = 13;
   class StringConversionSink extends ChunkedConversionSink$(core.String) {
     StringConversionSink() {
       super.ChunkedConversionSink();
     }
-    withCallback(callback) {
+    static withCallback(callback) {
       return new _StringCallbackSink(callback);
     }
-    from(sink) {
+    static from(sink) {
       return new _StringAdapterSink(sink);
     }
-    fromStringSink(sink) {
+    static fromStringSink(sink) {
       return new _StringSinkConversionSink(sink);
     }
   }
-  dart.defineNamedConstructor(StringConversionSink, 'withCallback');
-  dart.defineNamedConstructor(StringConversionSink, 'from');
-  dart.defineNamedConstructor(StringConversionSink, 'fromStringSink');
   dart.setSignature(StringConversionSink, {
     constructors: () => ({
       StringConversionSink: [StringConversionSink, []],
       withCallback: [StringConversionSink, [dart.functionType(dart.void, [core.String])]],
       from: [StringConversionSink, [core.Sink$(core.String)]],
       fromStringSink: [StringConversionSink, [core.StringSink]]
     })
   });
   class ClosableStringSink extends core.StringSink {
-    fromStringSink(sink, onClose) {
+    static fromStringSink(sink, onClose) {
       return new _ClosableStringSink(sink, onClose);
     }
   }
-  dart.defineNamedConstructor(ClosableStringSink, 'fromStringSink');
   dart.setSignature(ClosableStringSink, {
     constructors: () => ({fromStringSink: [ClosableStringSink, [core.StringSink, dart.functionType(dart.void, [])]]})
   });
   let _StringSinkCloseCallback = dart.typedef('_StringSinkCloseCallback', () => dart.functionType(dart.void, []));
   class _ClosableStringSink extends core.Object {
     _ClosableStringSink(sink, callback) {
       this[_sink] = sink;
       this[_callback] = callback;
     }
     close() {
@@ skipping 112 matching lines @@
       if (isLast)
         this.close();
     }
     add(str) {
       return this[_stringSink].write(str);
     }
     asUtf8Sink(allowMalformed) {
       return new _Utf8StringSinkAdapter(this, this[_stringSink], allowMalformed);
     }
     asStringSink() {
-      return new ClosableStringSink.fromStringSink(this[_stringSink], dart.bind(this, 'close'));
+      return ClosableStringSink.fromStringSink(this[_stringSink], dart.bind(this, 'close'));
     }
   }
   dart.setSignature(_StringSinkConversionSink, {
     constructors: () => ({_StringSinkConversionSink: [_StringSinkConversionSink, [core.StringSink]]}),
     methods: () => ({
       close: [dart.void, []],
       addSlice: [dart.void, [core.String, core.int, core.int, core.bool]]
     })
   });
   class _StringCallbackSink extends _StringSinkConversionSink {
@@ skipping 157 matching lines @@
       if (start === void 0)
         start = 0;
       if (end === void 0)
         end = null;
       let stringLength = string.length;
       core.RangeError.checkValidRange(start, end, stringLength);
       if (end == null)
         end = stringLength;
       let length = dart.notNull(end) - dart.notNull(start);
       if (length == 0)
-        return new typed_data.Uint8List(0);
+        return typed_data.Uint8List.new(0);
       let encoder = new _Utf8Encoder.withBufferSize(dart.notNull(length) * 3);
       let endPosition = encoder[_fillBuffer](string, start, end);
       dart.assert(dart.notNull(endPosition) >= dart.notNull(end) - 1);
       if (endPosition != end) {
         let lastCodeUnit = string.codeUnitAt(dart.notNull(end) - 1);
         dart.assert(_isLeadSurrogate(lastCodeUnit));
         let wasCombined = encoder[_writeSurrogate](lastCodeUnit, 0);
         dart.assert(!dart.notNull(wasCombined));
       }
       return encoder[_buffer][core.$sublist](0, encoder[_bufferIndex]);
     }
     startChunkedConversion(sink) {
       if (!dart.is(sink, ByteConversionSink)) {
-        sink = new ByteConversionSink.from(sink);
+        sink = ByteConversionSink.from(sink);
       }
       return new _Utf8EncoderSink(dart.as(sink, ByteConversionSink));
     }
     bind(stream) {
       return super.bind(stream);
     }
   }
   dart.setSignature(Utf8Encoder, {
     constructors: () => ({Utf8Encoder: [Utf8Encoder, []]}),
     methods: () => ({
       convert: [core.List$(core.int), [core.String], [core.int, core.int]],
       startChunkedConversion: [StringConversionSink, [core.Sink$(core.List$(core.int))]],
       bind: [async.Stream$(core.List$(core.int)), [async.Stream$(core.String)]]
     })
   });
   class _Utf8Encoder extends core.Object {
     _Utf8Encoder() {
       this.withBufferSize(_Utf8Encoder._DEFAULT_BYTE_BUFFER_SIZE);
     }
     withBufferSize(bufferSize) {
       this[_buffer] = _Utf8Encoder._createBuffer(bufferSize);
       this[_carry] = 0;
       this[_bufferIndex] = 0;
     }
     static _createBuffer(size) {
-      return new typed_data.Uint8List(size);
+      return typed_data.Uint8List.new(size);
     }
     [_writeSurrogate](leadingSurrogate, nextCodeUnit) {
       if (_isTailSurrogate(nextCodeUnit)) {
         let rune = _combineSurrogatePair(leadingSurrogate, nextCodeUnit);
         dart.assert(dart.notNull(rune) > dart.notNull(_THREE_BYTE_LIMIT));
         dart.assert(dart.notNull(rune) <= dart.notNull(_FOUR_BYTE_LIMIT));
         this[_buffer][core.$set]((() => {
           let x = this[_bufferIndex];
           this[_bufferIndex] = dart.notNull(x) + 1;
           return x;
@@ skipping 186 matching lines @@
       let decoder = new _Utf8Decoder(buffer, this[_allowMalformed]);
       decoder.convert(codeUnits, start, end);
       decoder.close();
       return dart.toString(buffer);
     }
     startChunkedConversion(sink) {
       let stringSink = null;
       if (dart.is(sink, StringConversionSink)) {
         stringSink = sink;
       } else {
-        stringSink = new StringConversionSink.from(sink);
+        stringSink = StringConversionSink.from(sink);
       }
       return stringSink.asUtf8Sink(this[_allowMalformed]);
     }
     bind(stream) {
       return super.bind(stream);
     }
     fuse(next) {
       return super.fuse(next);
     }
   }
@@ skipping 75 matching lines @@
           let unit = dart.dindex(units, i);
           if (!dart.equals(dart.dsend(unit, '&', mask), unit))
             return dart.notNull(i) - dart.notNull(from);
         }
         return dart.notNull(to) - dart.notNull(from);
       };
       dart.fn(scanOneByteCharacters, core.int, [core.Object, core.int]);
       let addSingleBytes = ((from, to) => {
         dart.assert(dart.notNull(from) >= dart.notNull(startIndex) && dart.notNull(from) <= dart.notNull(endIndex));
         dart.assert(dart.notNull(to) >= dart.notNull(startIndex) && dart.notNull(to) <= dart.notNull(endIndex));
-        this[_stringSink].write(new core.String.fromCharCodes(codeUnits, from, to));
+        this[_stringSink].write(core.String.fromCharCodes(codeUnits, from, to));
       }).bind(this);
       dart.fn(addSingleBytes, dart.void, [core.int, core.int]);
       let i = startIndex;
       loop:
         while (true) {
           multibyte:
             if (dart.notNull(expectedUnits) > 0) {
               do {
                 if (i == endIndex) {
                   break loop;
@@ skipping 174 matching lines @@
       return dart.notNull(this.length) > 0;
     }
     get keys() {
       if (this[_isUpgraded])
         return this[_upgradedMap].keys;
       return new _JsonMapKeyIterable(this);
     }
     get values() {
       if (this[_isUpgraded])
         return this[_upgradedMap].values;
-      return new _internal.MappedIterable(this[_computeKeys](), dart.fn((each => this.get(each)).bind(this)));
+      return _internal.MappedIterable.new(this[_computeKeys](), dart.fn((each => this.get(each)).bind(this)));
     }
     set(key, value) {
       if (this[_isUpgraded]) {
         this[_upgradedMap].set(key, value);
       } else if (this.containsKey(key)) {
         let processed = this[_processed];
         _JsonMap._setProperty(processed, dart.as(key, core.String), value);
         let original = this[_original];
         if (!dart.notNull(core.identical(original, processed))) {
           _JsonMap._setProperty(original, dart.as(key, core.String), null);
@@ skipping 229 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;
 })(convert, core, async, typed_data, _internal, collection);