Tag closures with their types

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 {
       Codec() {
       }
       encode(input) {
         dart.as(input, S);
         return this.encoder.convert(input);
       }
       decode(encoded) {
         dart.as(encoded, T);
         return this.decoder.convert(encoded);
       }
       fuse(other) {
         dart.as(other, Codec$(T, dart.dynamic));
         return new (_FusedCodec$(S, T, dart.dynamic))(this, other);
       }
       get inverted() {
         return new (_InvertedCodec$(T, S))(this);
       }
     }
+    dart.setSignature(Codec, {
+      methods: () => ({
+        encode: dart.functionType(T, [S]),
+        decode: dart.functionType(S, [T]),
+        fuse: dart.functionType(Codec$(S, dart.dynamic), [Codec$(T, dart.dynamic)])
+      })
+    });
     return Codec;
   });
   let Codec = Codec$();
   class Encoding extends Codec$(core.String, core.List$(core.int)) {
     Encoding() {
       super.Codec();
     }
     decodeStream(byteStream) {
-      return dart.as(byteStream.transform(this.decoder).fold(new core.StringBuffer(), (buffer, string) => ((() => {
+      return dart.as(byteStream.transform(this.decoder).fold(new core.StringBuffer(), dart.fn((buffer, string) => ((() => {
         dart.dsend(buffer, 'write', string);
         return buffer;
-      })())).then(buffer => dart.toString(buffer)), async.Future$(core.String));
+      })()))).then(dart.fn(buffer => dart.toString(buffer), core.String, [dart.dynamic])), async.Future$(core.String));
     }
     static getByName(name) {
       if (name == null)
         return null;
       name = name.toLowerCase();
       return Encoding._nameToEncoding.get(name);
     }
   }
+  dart.setSignature(Encoding, {
+    methods: () => ({decodeStream: dart.functionType(async.Future$(core.String), [async.Stream$(core.List$(core.int))])}),
+    statics: () => ({getByName: dart.functionType(Encoding, [core.String])}),
+    names: ['getByName']
+  });
   let _allowInvalid = Symbol('_allowInvalid');
   class AsciiCodec extends Encoding {
     AsciiCodec(opts) {
       let allowInvalid = opts && 'allowInvalid' in opts ? opts.allowInvalid : false;
       this[_allowInvalid] = allowInvalid;
       super.Encoding();
     }
     get name() {
       return "us-ascii";
     }
     decode(bytes, opts) {
       let allowInvalid = opts && 'allowInvalid' in opts ? opts.allowInvalid : null;
       if (allowInvalid == null)
         allowInvalid = this[_allowInvalid];
       if (allowInvalid) {
         return dart.const(new AsciiDecoder({allowInvalid: true})).convert(bytes);
       } else {
         return dart.const(new AsciiDecoder({allowInvalid: false})).convert(bytes);
       }
     }
     get encoder() {
       return dart.const(new AsciiEncoder());
     }
     get decoder() {
       return this[_allowInvalid] ? dart.const(new AsciiDecoder({allowInvalid: true})) : dart.const(new AsciiDecoder({allowInvalid: false}));
     }
   }
+  dart.setSignature(AsciiCodec, {
+    methods: () => ({decode: dart.functionType(core.String, [core.List$(core.int)], {llowInvali: core.bool})})
+  });
   let ASCII = dart.const(new AsciiCodec());
   let _ASCII_MASK = 127;
   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}`);
       }
       bind(source) {
         dart.as(source, async.Stream$(S));
-        return new (async.Stream$(T)).eventTransformed(source, (sink => new _ConverterStreamEventSink(this, sink)).bind(this));
+        return new (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, {
+      methods: () => ({
+        fuse: dart.functionType(Converter$(S, dart.dynamic), [Converter$(T, dart.dynamic)]),
+        startChunkedConversion: dart.functionType(ChunkedConversionSink, [core.Sink$(T)]),
+        bind: dart.functionType(async.Stream$(T), [async.Stream$(S)])
+      })
+    });
     return Converter;
   });
   let Converter = Converter$();
   let _subsetMask = Symbol('_subsetMask');
   class _UnicodeSubsetEncoder extends Converter$(core.String, core.List$(core.int)) {
     _UnicodeSubsetEncoder(subsetMask) {
       this[_subsetMask] = subsetMask;
       super.Converter();
     }
     convert(string, start, end) {
@@ skipping 19 matching lines @@
     startChunkedConversion(sink) {
       if (!dart.is(sink, ByteConversionSink)) {
         sink = new ByteConversionSink.from(sink);
       }
       return new _UnicodeSubsetEncoderSink(this[_subsetMask], dart.as(sink, ByteConversionSink));
     }
     bind(stream) {
       return super.bind(stream);
     }
   }
+  dart.setSignature(_UnicodeSubsetEncoder, {
+    methods: () => ({
+      convert: dart.functionType(core.List$(core.int), [core.String], [core.int, core.int]),
+      startChunkedConversion: dart.functionType(StringConversionSink, [core.Sink$(core.List$(core.int))]),
+      bind: dart.functionType(async.Stream$(core.List$(core.int)), [async.Stream$(core.String)])
+    })
+  });
   class AsciiEncoder extends _UnicodeSubsetEncoder {
     AsciiEncoder() {
       super._UnicodeSubsetEncoder(_ASCII_MASK);
     }
   }
+  dart.setSignature(AsciiEncoder, {});
   class StringConversionSinkMixin extends core.Object {
     add(str) {
       return this.addSlice(str, 0, str.length, false);
     }
     asUtf8Sink(allowMalformed) {
       return new _Utf8ConversionSink(this, allowMalformed);
     }
     asStringSink() {
       return new _StringConversionSinkAsStringSinkAdapter(this);
     }
   }
   StringConversionSinkMixin[dart.implements] = () => [StringConversionSink];
+  dart.setSignature(StringConversionSinkMixin, {
+    methods: () => ({
+      add: dart.functionType(dart.void, [core.String]),
+      asUtf8Sink: dart.functionType(ByteConversionSink, [core.bool]),
+      asStringSink: dart.functionType(ClosableStringSink, [])
+    })
+  });
   class StringConversionSinkBase extends StringConversionSinkMixin {}
+  dart.setSignature(StringConversionSinkBase, {});
   let _sink = Symbol('_sink');
   class _UnicodeSubsetEncoderSink extends StringConversionSinkBase {
     _UnicodeSubsetEncoderSink(subsetMask, sink) {
       this[_subsetMask] = subsetMask;
       this[_sink] = sink;
     }
     close() {
       this[_sink].close();
     }
     addSlice(source, start, end, isLast) {
       core.RangeError.checkValidRange(start, end, source.length);
       for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
         let codeUnit = source.codeUnitAt(i);
         if ((dart.notNull(codeUnit) & ~dart.notNull(this[_subsetMask])) != 0) {
           throw new core.ArgumentError(`Source contains invalid character with code point: ${codeUnit}.`);
         }
       }
       this[_sink].add(source.codeUnits[core.$sublist](start, end));
       if (isLast) {
         this.close();
       }
     }
   }
+  dart.setSignature(_UnicodeSubsetEncoderSink, {
+    methods: () => ({
+      close: dart.functionType(dart.void, []),
+      addSlice: dart.functionType(dart.void, [core.String, core.int, core.int, core.bool])
+    })
+  });
   let _convertInvalid = Symbol('_convertInvalid');
   class _UnicodeSubsetDecoder extends Converter$(core.List$(core.int), core.String) {
     _UnicodeSubsetDecoder(allowInvalid, subsetMask) {
       this[_allowInvalid] = allowInvalid;
       this[_subsetMask] = subsetMask;
       super.Converter();
     }
     convert(bytes, start, end) {
       if (start === void 0)
         start = 0;
@@ skipping 22 matching lines @@
         if ((dart.notNull(value) & ~dart.notNull(this[_subsetMask])) != 0)
           value = 65533;
         buffer.writeCharCode(value);
       }
       return dart.toString(buffer);
     }
     bind(stream) {
       return super.bind(stream);
     }
   }
+  dart.setSignature(_UnicodeSubsetDecoder, {
+    methods: () => ({
+      convert: dart.functionType(core.String, [core.List$(core.int)], [core.int, core.int]),
+      [_convertInvalid]: dart.functionType(core.String, [core.List$(core.int), core.int, core.int]),
+      bind: dart.functionType(async.Stream$(core.String), [async.Stream$(core.List$(core.int))])
+    })
+  });
   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);
       }
       if (this[_allowInvalid]) {
         return new _ErrorHandlingAsciiDecoderSink(stringSink.asUtf8Sink(false));
       } else {
         return new _SimpleAsciiDecoderSink(stringSink);
       }
     }
   }
+  dart.setSignature(AsciiDecoder, {
+    methods: () => ({startChunkedConversion: dart.functionType(ByteConversionSink, [core.Sink$(core.String)])})
+  });
   let ChunkedConversionSink$ = dart.generic(function(T) {
     class ChunkedConversionSink extends core.Object {
       ChunkedConversionSink() {
       }
       withCallback(callback) {
         return new _SimpleCallbackSink(callback);
       }
     }
     ChunkedConversionSink[dart.implements] = () => [core.Sink$(T)];
     dart.defineNamedConstructor(ChunkedConversionSink, 'withCallback');
+    dart.setSignature(ChunkedConversionSink, {});
     return ChunkedConversionSink;
   });
   let ChunkedConversionSink = ChunkedConversionSink$();
   class ByteConversionSink extends ChunkedConversionSink$(core.List$(core.int)) {
     ByteConversionSink() {
       super.ChunkedConversionSink();
     }
     withCallback(callback) {
       return new _ByteCallbackSink(callback);
     }
     from(sink) {
       return new _ByteAdapterSink(sink);
     }
   }
   dart.defineNamedConstructor(ByteConversionSink, 'withCallback');
   dart.defineNamedConstructor(ByteConversionSink, 'from');
+  dart.setSignature(ByteConversionSink, {});
   class ByteConversionSinkBase extends ByteConversionSink {
     ByteConversionSinkBase() {
       super.ByteConversionSink();
     }
     addSlice(chunk, start, end, isLast) {
       this.add(chunk[core.$sublist](start, end));
       if (isLast)
         this.close();
     }
   }
+  dart.setSignature(ByteConversionSinkBase, {
+    methods: () => ({addSlice: dart.functionType(dart.void, [core.List$(core.int), core.int, core.int, core.bool])})
+  });
   let _utf8Sink = Symbol('_utf8Sink');
   class _ErrorHandlingAsciiDecoderSink extends ByteConversionSinkBase {
     _ErrorHandlingAsciiDecoderSink(utf8Sink) {
       this[_utf8Sink] = utf8Sink;
     }
     close() {
       this[_utf8Sink].close();
     }
     add(source) {
       this.addSlice(source, 0, source[core.$length], false);
     }
     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) {
         if ((dart.notNull(source[core.$get](i)) & ~dart.notNull(_ASCII_MASK)) != 0) {
           if (dart.notNull(i) > dart.notNull(start))
             this[_utf8Sink].addSlice(source, start, i, false);
           this[_utf8Sink].add(dart.const(dart.setType([239, 191, 189], core.List$(core.int))));
           start = dart.notNull(i) + 1;
         }
       }
       if (dart.notNull(start) < dart.notNull(end)) {
         this[_utf8Sink].addSlice(source, start, end, isLast);
       } else if (isLast) {
         this.close();
       }
     }
   }
+  dart.setSignature(_ErrorHandlingAsciiDecoderSink, {
+    methods: () => ({
+      close: dart.functionType(dart.void, []),
+      add: dart.functionType(dart.void, [core.List$(core.int)]),
+      addSlice: dart.functionType(dart.void, [core.List$(core.int), core.int, core.int, core.bool])
+    })
+  });
   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[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));
     }
     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);
       }
       if (isLast)
         this.close();
     }
   }
+  dart.setSignature(_SimpleAsciiDecoderSink, {
+    methods: () => ({
+      close: dart.functionType(dart.void, []),
+      add: dart.functionType(dart.void, [core.List$(core.int)]),
+      addSlice: dart.functionType(dart.void, [core.List$(core.int), core.int, core.int, core.bool])
+    })
+  });
   class _ByteAdapterSink extends ByteConversionSinkBase {
     _ByteAdapterSink(sink) {
       this[_sink] = sink;
     }
     add(chunk) {
       return this[_sink].add(chunk);
     }
     close() {
       return this[_sink].close();
     }
   }
+  dart.setSignature(_ByteAdapterSink, {
+    methods: () => ({
+      add: dart.functionType(dart.void, [core.List$(core.int)]),
+      close: dart.functionType(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[_callback] = callback;
       this[_bufferIndex] = 0;
     }
     add(chunk) {
@@ skipping 16 matching lines @@
       v = dart.notNull(v) | dart.notNull(v) >> 4;
       v = dart.notNull(v) | dart.notNull(v) >> 8;
       v = dart.notNull(v) | dart.notNull(v) >> 16;
       v = dart.notNull(v) + 1;
       return v;
     }
     close() {
       this[_callback](this[_buffer][core.$sublist](0, this[_bufferIndex]));
     }
   }
+  dart.setSignature(_ByteCallbackSink, {
+    methods: () => ({
+      add: dart.functionType(dart.void, [core.Iterable$(core.int)]),
+      close: dart.functionType(dart.void, [])
+    }),
+    statics: () => ({_roundToPowerOf2: dart.functionType(core.int, [core.int])}),
+    names: ['_roundToPowerOf2']
+  });
   _ByteCallbackSink._INITIAL_BUFFER_SIZE = 1024;
   let _ChunkedConversionCallback$ = dart.generic(function(T) {
     let _ChunkedConversionCallback = dart.typedef('_ChunkedConversionCallback', () => dart.functionType(dart.void, [T]));
     return _ChunkedConversionCallback;
   });
   let _ChunkedConversionCallback = _ChunkedConversionCallback$();
   let _accumulated = Symbol('_accumulated');
   let _SimpleCallbackSink$ = dart.generic(function(T) {
     class _SimpleCallbackSink extends ChunkedConversionSink$(T) {
       _SimpleCallbackSink(callback) {
         this[_accumulated] = dart.setType([], core.List$(T));
         this[_callback] = callback;
         super.ChunkedConversionSink();
       }
       add(chunk) {
         dart.as(chunk, T);
         this[_accumulated][core.$add](chunk);
       }
       close() {
         this[_callback](this[_accumulated]);
       }
     }
+    dart.setSignature(_SimpleCallbackSink, {
+      methods: () => ({
+        add: dart.functionType(dart.void, [T]),
+        close: dart.functionType(dart.void, [])
+      })
+    });
     return _SimpleCallbackSink;
   });
   let _SimpleCallbackSink = _SimpleCallbackSink$();
   let _EventSinkAdapter$ = dart.generic(function(T) {
     class _EventSinkAdapter extends core.Object {
       _EventSinkAdapter(sink) {
         this[_sink] = sink;
       }
       add(data) {
         dart.as(data, T);
         return this[_sink].add(data);
       }
       close() {
         return this[_sink].close();
       }
     }
     _EventSinkAdapter[dart.implements] = () => [ChunkedConversionSink$(T)];
+    dart.setSignature(_EventSinkAdapter, {
+      methods: () => ({
+        add: dart.functionType(dart.void, [T]),
+        close: dart.functionType(dart.void, [])
+      })
+    });
     return _EventSinkAdapter;
   });
   let _EventSinkAdapter = _EventSinkAdapter$();
   let _eventSink = Symbol('_eventSink');
   let _chunkedSink = Symbol('_chunkedSink');
   let _ConverterStreamEventSink$ = dart.generic(function(S, T) {
     class _ConverterStreamEventSink extends core.Object {
       _ConverterStreamEventSink(converter, sink) {
         this[_eventSink] = sink;
         this[_chunkedSink] = converter.startChunkedConversion(sink);
       }
       add(o) {
         dart.as(o, S);
         return this[_chunkedSink].add(o);
       }
       addError(error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
         this[_eventSink].addError(error, stackTrace);
       }
       close() {
         return this[_chunkedSink].close();
       }
     }
     _ConverterStreamEventSink[dart.implements] = () => [async.EventSink$(S)];
+    dart.setSignature(_ConverterStreamEventSink, {
+      methods: () => ({
+        add: dart.functionType(dart.void, [S]),
+        addError: dart.functionType(dart.void, [core.Object], [core.StackTrace]),
+        close: dart.functionType(dart.void, [])
+      })
+    });
     return _ConverterStreamEventSink;
   });
   let _ConverterStreamEventSink = _ConverterStreamEventSink$();
   let _first = Symbol('_first');
   let _second = Symbol('_second');
   let _FusedCodec$ = dart.generic(function(S, M, T) {
     class _FusedCodec extends Codec$(S, T) {
       get encoder() {
         return dart.as(this[_first].encoder.fuse(this[_second].encoder), Converter$(S, T));
       }
       get decoder() {
         return dart.as(this[_second].decoder.fuse(this[_first].decoder), Converter$(T, S));
       }
       _FusedCodec(first, second) {
         this[_first] = first;
         this[_second] = second;
         super.Codec();
       }
     }
+    dart.setSignature(_FusedCodec, {});
     return _FusedCodec;
   });
   let _FusedCodec = _FusedCodec$();
   let _codec = Symbol('_codec');
   let _InvertedCodec$ = dart.generic(function(T, S) {
     class _InvertedCodec extends Codec$(T, S) {
       _InvertedCodec(codec) {
         this[_codec] = codec;
         super.Codec();
       }
       get encoder() {
         return this[_codec].decoder;
       }
       get decoder() {
         return this[_codec].encoder;
       }
       get inverted() {
         return this[_codec];
       }
     }
+    dart.setSignature(_InvertedCodec, {});
     return _InvertedCodec;
   });
   let _InvertedCodec = _InvertedCodec$();
   let _FusedConverter$ = dart.generic(function(S, M, T) {
     class _FusedConverter extends Converter$(S, T) {
       _FusedConverter(first, second) {
         this[_first] = first;
         this[_second] = second;
         super.Converter();
       }
       convert(input) {
         dart.as(input, S);
         return dart.as(this[_second].convert(this[_first].convert(input)), T);
       }
       startChunkedConversion(sink) {
         dart.as(sink, core.Sink$(T));
         return this[_first].startChunkedConversion(this[_second].startChunkedConversion(sink));
       }
     }
+    dart.setSignature(_FusedConverter, {
+      methods: () => ({
+        convert: dart.functionType(T, [S]),
+        startChunkedConversion: dart.functionType(ChunkedConversionSink, [core.Sink$(T)])
+      })
+    });
     return _FusedConverter;
   });
   let _FusedConverter = _FusedConverter$();
   dart.defineLazyProperties(Encoding, {
     get _nameToEncoding() {
       return dart.map({"iso_8859-1:1987": LATIN1, "iso-ir-100": LATIN1, "iso_8859-1": LATIN1, "iso-8859-1": LATIN1, latin1: LATIN1, l1: LATIN1, ibm819: LATIN1, cp819: LATIN1, csisolatin1: LATIN1, "iso-ir-6": ASCII, "ansi_x3.4-1968": ASCII, "ansi_x3.4-1986": ASCII, "iso_646.irv:1991": ASCII, "iso646-us": ASCII, "us-ascii": ASCII, us: ASCII, ibm367: ASCII, cp367: ASCII, csascii: ASCII, ascii: ASCII, csutf8: UTF8, "utf-8": UTF8});
     },
     set _nameToEncoding(_) {}
   });
   let _convert = Symbol('_convert');
@@ skipping 65 matching lines @@
       }
       return result != null ? dart.toString(result) : null;
     }
     startChunkedConversion(sink) {
       if (!dart.is(sink, StringConversionSink)) {
         sink = new StringConversionSink.from(sink);
       }
       return new _HtmlEscapeSink(this, dart.as(sink, StringConversionSink));
     }
   }
+  dart.setSignature(HtmlEscape, {
+    methods: () => ({
+      convert: dart.functionType(core.String, [core.String]),
+      [_convert]: dart.functionType(core.String, [core.String, core.int, core.int]),
+      startChunkedConversion: dart.functionType(StringConversionSink, [core.Sink$(core.String)])
+    })
+  });
   let HTML_ESCAPE = dart.const(new HtmlEscape());
   let _name = Symbol('_name');
   class HtmlEscapeMode extends core.Object {
     _(name, escapeLtGt, escapeQuot, escapeApos, escapeSlash) {
       this[_name] = name;
       this.escapeLtGt = escapeLtGt;
       this.escapeQuot = escapeQuot;
       this.escapeApos = escapeApos;
       this.escapeSlash = escapeSlash;
     }
     toString() {
       return this[_name];
     }
   }
   dart.defineNamedConstructor(HtmlEscapeMode, '_');
+  dart.setSignature(HtmlEscapeMode, {
+    methods: () => ({toString: dart.functionType(core.String, [])})
+  });
   HtmlEscapeMode.UNKNOWN = dart.const(new HtmlEscapeMode._('unknown', true, true, true, true));
   HtmlEscapeMode.ATTRIBUTE = dart.const(new HtmlEscapeMode._('attribute', false, true, false, false));
   HtmlEscapeMode.ELEMENT = dart.const(new HtmlEscapeMode._('element', true, false, false, true));
   let _escape = Symbol('_escape');
   class _HtmlEscapeSink extends StringConversionSinkBase {
     _HtmlEscapeSink(escape, sink) {
       this[_escape] = escape;
       this[_sink] = sink;
     }
     addSlice(chunk, start, end, isLast) {
       let val = this[_escape][_convert](chunk, start, end);
       if (val == null) {
         this[_sink].addSlice(chunk, start, end, isLast);
       } else {
         this[_sink].add(val);
         if (isLast)
           this[_sink].close();
       }
     }
     close() {
       return this[_sink].close();
     }
   }
+  dart.setSignature(_HtmlEscapeSink, {
+    methods: () => ({
+      addSlice: dart.functionType(dart.void, [core.String, core.int, core.int, core.bool]),
+      close: dart.functionType(dart.void, [])
+    })
+  });
   class JsonUnsupportedObjectError extends core.Error {
     JsonUnsupportedObjectError(unsupportedObject, opts) {
       let cause = opts && 'cause' in opts ? opts.cause : null;
       this.unsupportedObject = unsupportedObject;
       this.cause = cause;
       super.Error();
     }
     toString() {
       if (this.cause != null) {
         return "Converting object to an encodable object failed.";
       } else {
         return "Converting object did not return an encodable object.";
       }
     }
   }
+  dart.setSignature(JsonUnsupportedObjectError, {
+    methods: () => ({toString: dart.functionType(core.String, [])})
+  });
   class JsonCyclicError extends JsonUnsupportedObjectError {
     JsonCyclicError(object) {
       super.JsonUnsupportedObjectError(object);
     }
     toString() {
       return "Cyclic error in JSON stringify";
     }
   }
+  dart.setSignature(JsonCyclicError, {
+    methods: () => ({toString: dart.functionType(core.String, [])})
+  });
   let _reviver = Symbol('_reviver');
   let _toEncodable$ = Symbol('_toEncodable');
   class JsonCodec extends Codec$(core.Object, core.String) {
     JsonCodec(opts) {
       let reviver = opts && 'reviver' in opts ? opts.reviver : null;
       let toEncodable = opts && 'toEncodable' in opts ? opts.toEncodable : null;
       this[_reviver] = reviver;
       this[_toEncodable$] = toEncodable;
       super.Codec();
     }
@@ skipping 21 matching lines @@
         return dart.const(new JsonEncoder());
       return new JsonEncoder(dart.as(this[_toEncodable$], dart.functionType(core.Object, [core.Object])));
     }
     get decoder() {
       if (this[_reviver] == null)
         return dart.const(new JsonDecoder());
       return new JsonDecoder(this[_reviver]);
     }
   }
   dart.defineNamedConstructor(JsonCodec, 'withReviver');
+  dart.setSignature(JsonCodec, {
+    methods: () => ({
+      decode: dart.functionType(dart.dynamic, [core.String], {evive: dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])}),
+      encode: dart.functionType(core.String, [core.Object], {oEncodabl: dart.functionType(dart.dynamic, [dart.dynamic])})
+    })
+  });
   let JSON = dart.const(new JsonCodec());
   let _Reviver = dart.typedef('_Reviver', () => dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]));
   let _ToEncodable = dart.typedef('_ToEncodable', () => dart.functionType(dart.dynamic, [dart.dynamic]));
   class JsonEncoder extends Converter$(core.Object, core.String) {
     JsonEncoder(toEncodable) {
       if (toEncodable === void 0)
         toEncodable = null;
       this.indent = null;
       this[_toEncodable$] = toEncodable;
       super.Converter();
@@ skipping 20 matching lines @@
       return super.bind(stream);
     }
     fuse(other) {
       if (dart.is(other, Utf8Encoder)) {
         return new JsonUtf8Encoder(this.indent, dart.as(this[_toEncodable$], __CastType4));
       }
       return super.fuse(other);
     }
   }
   dart.defineNamedConstructor(JsonEncoder, 'withIndent');
+  dart.setSignature(JsonEncoder, {
+    methods: () => ({
+      convert: dart.functionType(core.String, [core.Object]),
+      startChunkedConversion: dart.functionType(ChunkedConversionSink$(core.Object), [core.Sink$(core.String)]),
+      bind: dart.functionType(async.Stream$(core.String), [async.Stream$(core.Object)]),
+      fuse: dart.functionType(Converter$(core.Object, dart.dynamic), [Converter$(core.String, dart.dynamic)])
+    })
+  });
   let _indent = Symbol('_indent');
   let _bufferSize = Symbol('_bufferSize');
   class JsonUtf8Encoder extends Converter$(core.Object, core.List$(core.int)) {
     JsonUtf8Encoder(indent, toEncodable, bufferSize) {
       if (indent === void 0)
         indent = null;
       if (toEncodable === void 0)
         toEncodable = null;
       if (bufferSize === void 0)
         bufferSize = JsonUtf8Encoder.DEFAULT_BUFFER_SIZE;
@@ skipping 11 matching lines @@
         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)));
-      // Function addChunk: (Uint8List, int, int) → void
       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);
         }
         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(dart.dynamic, [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);
       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);
@@ skipping 12 matching lines @@
       }
       return new _JsonUtf8EncoderSink(byteSink, this[_toEncodable$], this[_indent], this[_bufferSize]);
     }
     bind(stream) {
       return super.bind(stream);
     }
     fuse(other) {
       return super.fuse(other);
     }
   }
+  dart.setSignature(JsonUtf8Encoder, {
+    methods: () => ({
+      convert: dart.functionType(core.List$(core.int), [core.Object]),
+      startChunkedConversion: dart.functionType(ChunkedConversionSink$(core.Object), [core.Sink$(core.List$(core.int))]),
+      bind: dart.functionType(async.Stream$(core.List$(core.int)), [async.Stream$(core.Object)]),
+      fuse: dart.functionType(Converter$(core.Object, dart.dynamic), [Converter$(core.List$(core.int), dart.dynamic)])
+    }),
+    statics: () => ({_utf8Encode: dart.functionType(core.List$(core.int), [core.String])}),
+    names: ['_utf8Encode']
+  });
   JsonUtf8Encoder.DEFAULT_BUFFER_SIZE = 256;
   let _isDone = Symbol('_isDone');
   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 (this[_isDone]) {
         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, {
+    methods: () => ({
+      add: dart.functionType(dart.void, [core.Object]),
+      close: dart.functionType(dart.void, [])
+    })
+  });
   let _addChunk = Symbol('_addChunk');
   class _JsonUtf8EncoderSink extends ChunkedConversionSink$(core.Object) {
     _JsonUtf8EncoderSink(sink, toEncodable, indent, bufferSize) {
       this[_sink] = sink;
       this[_toEncodable$] = toEncodable;
       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 (this[_isDone]) {
         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], this[_addChunk].bind(this));
       this[_sink].close();
     }
     close() {
       if (!dart.notNull(this[_isDone])) {
         this[_isDone] = true;
         this[_sink].close();
       }
     }
   }
+  dart.setSignature(_JsonUtf8EncoderSink, {
+    methods: () => ({
+      [_addChunk]: dart.functionType(dart.void, [typed_data.Uint8List, core.int, core.int]),
+      add: dart.functionType(dart.void, [core.Object]),
+      close: dart.functionType(dart.void, [])
+    })
+  });
   class JsonDecoder extends Converter$(core.String, core.Object) {
     JsonDecoder(reviver) {
       if (reviver === void 0)
         reviver = null;
       this[_reviver] = reviver;
       super.Converter();
     }
     convert(input) {
       return _parseJson(input, this[_reviver]);
     }
     startChunkedConversion(sink) {
       return new _JsonDecoderSink(this[_reviver], sink);
     }
     bind(stream) {
       return super.bind(stream);
     }
   }
-  // Function _parseJson: (String, (dynamic, dynamic) → dynamic) → dynamic
+  dart.setSignature(JsonDecoder, {
+    methods: () => ({
+      convert: dart.functionType(dart.dynamic, [core.String]),
+      startChunkedConversion: dart.functionType(StringConversionSink, [core.Sink$(core.Object)]),
+      bind: dart.functionType(async.Stream$(core.Object), [async.Stream$(core.String)])
+    })
+  });
   function _parseJson(source, reviver) {
     if (!(typeof source == 'string'))
       throw new core.ArgumentError(source);
     let parsed = null;
     try {
       parsed = JSON.parse(source);
     } catch (e) {
       throw new core.FormatException(String(e));
     }
 
     if (reviver == null) {
       return _convertJsonToDartLazy(parsed);
     } else {
       return _convertJsonToDart(parsed, reviver);
     }
   }
-  // Function _defaultToEncodable: (dynamic) → Object
+  dart.fn(_parseJson, dart.dynamic, [core.String, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]);
   function _defaultToEncodable(object) {
     return dart.dsend(object, 'toJson');
   }
+  dart.fn(_defaultToEncodable, core.Object, [dart.dynamic]);
   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[_toEncodable$] = _toEncodable != null ? _toEncodable : _defaultToEncodable;
     }
     static hexDigit(x) {
       return dart.notNull(x) < 10 ? 48 + dart.notNull(x) : 87 + dart.notNull(x);
@@ skipping 129 matching lines @@
         for (let i = 1; dart.notNull(i) < dart.notNull(list[core.$length]); i = dart.notNull(i) + 1) {
           this.writeString(',');
           this.writeObject(list[core.$get](i));
         }
       }
       this.writeString(']');
     }
     writeMap(map) {
       this.writeString('{');
       let separator = '"';
-      map.forEach(((key, value) => {
+      map.forEach(dart.fn(((key, value) => {
         this.writeString(separator);
         separator = ',"';
         this.writeStringContent(key);
         this.writeString('":');
         this.writeObject(value);
-      }).bind(this));
+      }).bind(this), dart.dynamic, [core.String, dart.dynamic]));
       this.writeString('}');
     }
   }
+  dart.setSignature(_JsonStringifier, {
+    methods: () => ({
+      writeStringContent: dart.functionType(dart.void, [core.String]),
+      [_checkCycle]: dart.functionType(dart.void, [dart.dynamic]),
+      [_removeSeen]: dart.functionType(dart.void, [dart.dynamic]),
+      writeObject: dart.functionType(dart.void, [dart.dynamic]),
+      writeJsonValue: dart.functionType(core.bool, [dart.dynamic]),
+      writeList: dart.functionType(dart.void, [core.List]),
+      writeMap: dart.functionType(dart.void, [core.Map$(core.String, core.Object)])
+    }),
+    statics: () => ({hexDigit: dart.functionType(core.int, [core.int])}),
+    names: ['hexDigit']
+  });
   _JsonStringifier.BACKSPACE = 8;
   _JsonStringifier.TAB = 9;
   _JsonStringifier.NEWLINE = 10;
   _JsonStringifier.CARRIAGE_RETURN = 13;
   _JsonStringifier.FORM_FEED = 12;
   _JsonStringifier.QUOTE = 34;
   _JsonStringifier.CHAR_0 = 48;
   _JsonStringifier.BACKSLASH = 92;
   _JsonStringifier.CHAR_b = 98;
   _JsonStringifier.CHAR_f = 102;
@@ skipping 25 matching lines @@
         this.writeString(']');
       }
     }
     writeMap(map) {
       if (map.isEmpty) {
         this.writeString('{}');
       } else {
         this.writeString('{\n');
         this[_indentLevel] = dart.notNull(this[_indentLevel]) + 1;
         let first = true;
-        map.forEach(((key, value) => {
+        map.forEach(dart.fn(((key, value) => {
           if (!dart.notNull(first)) {
             this.writeString(",\n");
           }
           this.writeIndentation(this[_indentLevel]);
           this.writeString('"');
           this.writeStringContent(key);
           this.writeString('": ');
           this.writeObject(value);
           first = false;
-        }).bind(this));
+        }).bind(this), dart.dynamic, [core.String, core.Object]));
         this.writeString('\n');
         this[_indentLevel] = dart.notNull(this[_indentLevel]) - 1;
         this.writeIndentation(this[_indentLevel]);
         this.writeString('}');
       }
     }
   }
   _JsonPrettyPrintMixin[dart.implements] = () => [_JsonStringifier];
+  dart.setSignature(_JsonPrettyPrintMixin, {
+    methods: () => ({
+      writeList: dart.functionType(dart.void, [core.List]),
+      writeMap: dart.functionType(dart.void, [core.Map])
+    })
+  });
   class _JsonStringStringifier extends _JsonStringifier {
     _JsonStringStringifier(sink, _toEncodable) {
       this[_sink] = sink;
       super._JsonStringifier(dart.as(_toEncodable, dart.functionType(core.Object, [core.Object])));
     }
     static stringify(object, toEncodable, indent) {
       let output = new core.StringBuffer();
       _JsonStringStringifier.printOn(object, output, toEncodable, indent);
       return dart.toString(output);
     }
@@ skipping 12 matching lines @@
     writeString(string) {
       this[_sink].write(string);
     }
     writeStringSlice(string, start, end) {
       this[_sink].write(string.substring(start, end));
     }
     writeCharCode(charCode) {
       this[_sink].writeCharCode(charCode);
     }
   }
+  dart.setSignature(_JsonStringStringifier, {
+    methods: () => ({
+      writeNumber: dart.functionType(dart.void, [core.num]),
+      writeString: dart.functionType(dart.void, [core.String]),
+      writeStringSlice: dart.functionType(dart.void, [core.String, core.int, core.int]),
+      writeCharCode: dart.functionType(dart.void, [core.int])
+    }),
+    statics: () => ({
+      stringify: dart.functionType(core.String, [dart.dynamic, dart.functionType(dart.dynamic, [dart.dynamic]), core.String]),
+      printOn: dart.functionType(dart.void, [dart.dynamic, core.StringSink, dart.functionType(dart.dynamic, [dart.dynamic]), core.String])
+    }),
+    names: ['stringify', 'printOn']
+  });
   class _JsonStringStringifierPretty extends dart.mixin(_JsonStringStringifier, _JsonPrettyPrintMixin) {
     _JsonStringStringifierPretty(sink, toEncodable, indent) {
       this[_indent] = indent;
       super._JsonStringStringifier(sink, toEncodable);
     }
     writeIndentation(count) {
       for (let i = 0; dart.notNull(i) < dart.notNull(count); i = dart.notNull(i) + 1)
         this.writeString(this[_indent]);
     }
   }
+  dart.setSignature(_JsonStringStringifierPretty, {
+    methods: () => ({writeIndentation: dart.functionType(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.index = 0;
       super._JsonStringifier(dart.as(toEncodable, dart.functionType(core.Object, [core.Object])));
     }
     static stringify(object, indent, toEncodableFunction, bufferSize, addChunk) {
       let stringifier = null;
@@ skipping 79 matching lines @@
         this.buffer = new typed_data.Uint8List(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, {
+    methods: () => ({
+      flush: dart.functionType(dart.void, []),
+      writeNumber: dart.functionType(dart.void, [core.num]),
+      writeAsciiString: dart.functionType(dart.void, [core.String]),
+      writeString: dart.functionType(dart.void, [core.String]),
+      writeStringSlice: dart.functionType(dart.void, [core.String, core.int, core.int]),
+      writeCharCode: dart.functionType(dart.void, [core.int]),
+      writeMultiByteCharCode: dart.functionType(dart.void, [core.int]),
+      writeFourByteCharCode: dart.functionType(dart.void, [core.int]),
+      writeByte: dart.functionType(dart.void, [core.int])
+    }),
+    statics: () => ({stringify: dart.functionType(dart.void, [core.Object, core.List$(core.int), dart.functionType(dart.dynamic, [core.Object]), core.int, dart.functionType(dart.void, [typed_data.Uint8List, core.int, core.int])])}),
+    names: ['stringify']
+  });
   class _JsonUtf8StringifierPretty extends dart.mixin(_JsonUtf8Stringifier, _JsonPrettyPrintMixin) {
     _JsonUtf8StringifierPretty(toEncodableFunction, indent, bufferSize, addChunk) {
       this.indent = indent;
       super._JsonUtf8Stringifier(toEncodableFunction, dart.as(bufferSize, core.int), dart.as(addChunk, core.Function));
     }
     writeIndentation(count) {
       let indent = this.indent;
       let indentLength = indent[core.$length];
       if (indentLength == 1) {
         let char = indent[core.$get](0);
@@ skipping 10 matching lines @@
           this.buffer[core.$setRange](this.index, end, indent);
           this.index = end;
         } else {
           for (let i = 0; dart.notNull(i) < dart.notNull(indentLength); i = dart.notNull(i) + 1) {
             this.writeByte(indent[core.$get](i));
           }
         }
       }
     }
   }
+  dart.setSignature(_JsonUtf8StringifierPretty, {
+    methods: () => ({writeIndentation: dart.functionType(dart.void, [core.int])})
+  });
   let __CastType0 = dart.typedef('__CastType0', () => dart.functionType(core.Object, [core.Object]));
   let __CastType2 = dart.typedef('__CastType2', () => dart.functionType(dart.dynamic, [dart.dynamic]));
   let __CastType4 = dart.typedef('__CastType4', () => dart.functionType(dart.dynamic, [core.Object]));
   class Latin1Codec extends Encoding {
     Latin1Codec(opts) {
       let allowInvalid = opts && 'allowInvalid' in opts ? opts.allowInvalid : false;
       this[_allowInvalid] = allowInvalid;
       super.Encoding();
     }
     get name() {
       return "iso-8859-1";
     }
     decode(bytes, opts) {
       let allowInvalid = opts && 'allowInvalid' in opts ? opts.allowInvalid : null;
       if (allowInvalid == null)
         allowInvalid = this[_allowInvalid];
       if (allowInvalid) {
         return dart.const(new Latin1Decoder({allowInvalid: true})).convert(bytes);
       } else {
         return dart.const(new Latin1Decoder({allowInvalid: false})).convert(bytes);
       }
     }
     get encoder() {
       return dart.const(new Latin1Encoder());
     }
     get decoder() {
       return this[_allowInvalid] ? dart.const(new Latin1Decoder({allowInvalid: true})) : dart.const(new Latin1Decoder({allowInvalid: false}));
     }
   }
+  dart.setSignature(Latin1Codec, {
+    methods: () => ({decode: dart.functionType(core.String, [core.List$(core.int)], {llowInvali: core.bool})})
+  });
   let LATIN1 = dart.const(new Latin1Codec());
   let _LATIN1_MASK = 255;
   class Latin1Encoder extends _UnicodeSubsetEncoder {
     Latin1Encoder() {
       super._UnicodeSubsetEncoder(_LATIN1_MASK);
     }
   }
+  dart.setSignature(Latin1Encoder, {});
   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);
       }
       if (!dart.notNull(this[_allowInvalid]))
         return new _Latin1DecoderSink(stringSink);
       return new _Latin1AllowInvalidDecoderSink(stringSink);
     }
   }
+  dart.setSignature(Latin1Decoder, {
+    methods: () => ({startChunkedConversion: dart.functionType(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);
@@ skipping 12 matching lines @@
         }
       }
       if (dart.notNull(start) < dart.notNull(end)) {
         this[_addSliceToSink](source, start, end, isLast);
       }
       if (isLast) {
         this.close();
       }
     }
   }
+  dart.setSignature(_Latin1DecoderSink, {
+    methods: () => ({
+      close: dart.functionType(dart.void, []),
+      add: dart.functionType(dart.void, [core.List$(core.int)]),
+      [_addSliceToSink]: dart.functionType(dart.void, [core.List$(core.int), core.int, core.int, core.bool]),
+      addSlice: dart.functionType(dart.void, [core.List$(core.int), core.int, core.int, core.bool])
+    })
+  });
   class _Latin1AllowInvalidDecoderSink extends _Latin1DecoderSink {
     _Latin1AllowInvalidDecoderSink(sink) {
       super._Latin1DecoderSink(sink);
     }
     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) {
           if (dart.notNull(i) > dart.notNull(start))
             this[_addSliceToSink](source, start, i, false);
           this[_addSliceToSink](dart.const(dart.setType([65533], core.List$(core.int))), 0, 1, false);
           start = dart.notNull(i) + 1;
         }
       }
       if (dart.notNull(start) < dart.notNull(end)) {
         this[_addSliceToSink](source, start, end, isLast);
       }
       if (isLast) {
         this.close();
       }
     }
   }
+  dart.setSignature(_Latin1AllowInvalidDecoderSink, {
+    methods: () => ({addSlice: dart.functionType(dart.void, [core.List$(core.int), core.int, core.int, core.bool])})
+  });
   class LineSplitter extends Converter$(core.String, core.List$(core.String)) {
     LineSplitter() {
       super.Converter();
     }
     convert(data) {
       let lines = new (core.List$(core.String))();
       _LineSplitterSink._addSlice(data, 0, data.length, true, lines[core.$add].bind(lines));
       return lines;
     }
     startChunkedConversion(sink) {
       if (!dart.is(sink, StringConversionSink)) {
         sink = new StringConversionSink.from(dart.as(sink, core.Sink$(core.String)));
       }
       return new _LineSplitterSink(dart.as(sink, StringConversionSink));
     }
   }
+  dart.setSignature(LineSplitter, {
+    methods: () => ({
+      convert: dart.functionType(core.List$(core.String), [core.String]),
+      startChunkedConversion: dart.functionType(StringConversionSink, [core.Sink])
+    })
+  });
   let _carry = Symbol('_carry');
   class _LineSplitterSink extends StringConversionSinkBase {
     _LineSplitterSink(sink) {
       this[_sink] = sink;
       this[_carry] = null;
     }
     addSlice(chunk, start, end, isLast) {
       if (this[_carry] != null) {
         chunk = dart.notNull(this[_carry]) + dart.notNull(chunk.substring(start, end));
         start = 0;
@@ skipping 35 matching lines @@
         let carry = chunk.substring(start, pos);
         if (isLast) {
           adder(carry);
         } else {
           return carry;
         }
       }
       return null;
     }
   }
+  dart.setSignature(_LineSplitterSink, {
+    methods: () => ({
+      addSlice: dart.functionType(dart.void, [core.String, core.int, core.int, core.bool]),
+      close: dart.functionType(dart.void, [])
+    }),
+    statics: () => ({_addSlice: dart.functionType(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) {
       return new _StringCallbackSink(callback);
     }
     from(sink) {
       return new _StringAdapterSink(sink);
     }
     fromStringSink(sink) {
       return new _StringSinkConversionSink(sink);
     }
   }
   dart.defineNamedConstructor(StringConversionSink, 'withCallback');
   dart.defineNamedConstructor(StringConversionSink, 'from');
   dart.defineNamedConstructor(StringConversionSink, 'fromStringSink');
+  dart.setSignature(StringConversionSink, {});
   class ClosableStringSink extends core.StringSink {
     fromStringSink(sink, onClose) {
       return new _ClosableStringSink(sink, onClose);
     }
   }
   dart.defineNamedConstructor(ClosableStringSink, 'fromStringSink');
+  dart.setSignature(ClosableStringSink, {});
   let _StringSinkCloseCallback = dart.typedef('_StringSinkCloseCallback', () => dart.functionType(dart.void, []));
   class _ClosableStringSink extends core.Object {
     _ClosableStringSink(sink, callback) {
       this[_sink] = sink;
       this[_callback] = callback;
     }
     close() {
       return this[_callback]();
     }
     writeCharCode(charCode) {
       return this[_sink].writeCharCode(charCode);
     }
     write(o) {
       return this[_sink].write(o);
     }
     writeln(o) {
       if (o === void 0)
         o = "";
       return this[_sink].writeln(o);
     }
     writeAll(objects, separator) {
       if (separator === void 0)
         separator = "";
       return this[_sink].writeAll(objects, separator);
     }
   }
   _ClosableStringSink[dart.implements] = () => [ClosableStringSink];
+  dart.setSignature(_ClosableStringSink, {
+    methods: () => ({
+      close: dart.functionType(dart.void, []),
+      writeCharCode: dart.functionType(dart.void, [core.int]),
+      write: dart.functionType(dart.void, [core.Object]),
+      writeln: dart.functionType(dart.void, [], [core.Object]),
+      writeAll: dart.functionType(dart.void, [core.Iterable], [core.String])
+    })
+  });
   let _flush = Symbol('_flush');
   class _StringConversionSinkAsStringSinkAdapter extends core.Object {
     _StringConversionSinkAsStringSinkAdapter(chunkedSink) {
       this[_chunkedSink] = chunkedSink;
       this[_buffer] = new core.StringBuffer();
     }
     close() {
       if (this[_buffer].isNotEmpty)
         this[_flush]();
       this[_chunkedSink].close();
@@ skipping 36 matching lines @@
         }
       }
     }
     [_flush]() {
       let accumulated = dart.toString(this[_buffer]);
       this[_buffer].clear();
       this[_chunkedSink].add(accumulated);
     }
   }
   _StringConversionSinkAsStringSinkAdapter[dart.implements] = () => [ClosableStringSink];
+  dart.setSignature(_StringConversionSinkAsStringSinkAdapter, {
+    methods: () => ({
+      close: dart.functionType(dart.void, []),
+      writeCharCode: dart.functionType(dart.void, [core.int]),
+      write: dart.functionType(dart.void, [core.Object]),
+      writeln: dart.functionType(dart.void, [], [core.Object]),
+      writeAll: dart.functionType(dart.void, [core.Iterable], [core.String]),
+      [_flush]: dart.functionType(dart.void, [])
+    })
+  });
   _StringConversionSinkAsStringSinkAdapter._MIN_STRING_SIZE = 16;
   let _stringSink = Symbol('_stringSink');
   class _StringSinkConversionSink extends StringConversionSinkBase {
     _StringSinkConversionSink(stringSink) {
       this[_stringSink] = stringSink;
     }
     close() {}
     addSlice(str, start, end, isLast) {
       if (start != 0 || end != str.length) {
         for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
           this[_stringSink].writeCharCode(str.codeUnitAt(i));
         }
       } else {
         this[_stringSink].write(str);
       }
       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], this.close.bind(this));
     }
   }
+  dart.setSignature(_StringSinkConversionSink, {
+    methods: () => ({
+      close: dart.functionType(dart.void, []),
+      addSlice: dart.functionType(dart.void, [core.String, core.int, core.int, core.bool]),
+      add: dart.functionType(dart.void, [core.String]),
+      asUtf8Sink: dart.functionType(ByteConversionSink, [core.bool]),
+      asStringSink: dart.functionType(ClosableStringSink, [])
+    })
+  });
   class _StringCallbackSink extends _StringSinkConversionSink {
     _StringCallbackSink(callback) {
       this[_callback] = callback;
       super._StringSinkConversionSink(new core.StringBuffer());
     }
     close() {
       let buffer = dart.as(this[_stringSink], core.StringBuffer);
       let accumulated = dart.toString(buffer);
       buffer.clear();
       this[_callback](accumulated);
     }
     asUtf8Sink(allowMalformed) {
       return new _Utf8StringSinkAdapter(this, this[_stringSink], allowMalformed);
     }
   }
+  dart.setSignature(_StringCallbackSink, {
+    methods: () => ({
+      close: dart.functionType(dart.void, []),
+      asUtf8Sink: dart.functionType(ByteConversionSink, [core.bool])
+    })
+  });
   class _StringAdapterSink extends StringConversionSinkBase {
     _StringAdapterSink(sink) {
       this[_sink] = sink;
     }
     add(str) {
       return this[_sink].add(str);
     }
     addSlice(str, start, end, isLast) {
       if (start == 0 && end == str.length) {
         this.add(str);
       } else {
         this.add(str.substring(start, end));
       }
       if (isLast)
         this.close();
     }
     close() {
       return this[_sink].close();
     }
   }
+  dart.setSignature(_StringAdapterSink, {
+    methods: () => ({
+      add: dart.functionType(dart.void, [core.String]),
+      addSlice: dart.functionType(dart.void, [core.String, core.int, core.int, core.bool]),
+      close: dart.functionType(dart.void, [])
+    })
+  });
   let _decoder = Symbol('_decoder');
   class _Utf8StringSinkAdapter extends ByteConversionSink {
     _Utf8StringSinkAdapter(sink, stringSink, allowMalformed) {
       this[_sink] = sink;
       this[_decoder] = new _Utf8Decoder(stringSink, allowMalformed);
       super.ByteConversionSink();
     }
     close() {
       this[_decoder].close();
       if (this[_sink] != null)
         this[_sink].close();
     }
     add(chunk) {
       this.addSlice(chunk, 0, chunk[core.$length], false);
     }
     addSlice(codeUnits, startIndex, endIndex, isLast) {
       this[_decoder].convert(codeUnits, startIndex, endIndex);
       if (isLast)
         this.close();
     }
   }
+  dart.setSignature(_Utf8StringSinkAdapter, {
+    methods: () => ({
+      close: dart.functionType(dart.void, []),
+      add: dart.functionType(dart.void, [core.List$(core.int)]),
+      addSlice: dart.functionType(dart.void, [core.List$(core.int), core.int, core.int, core.bool])
+    })
+  });
   class _Utf8ConversionSink extends ByteConversionSink {
     _Utf8ConversionSink(sink, allowMalformed) {
       this._(sink, new core.StringBuffer(), allowMalformed);
     }
     _(chunkedSink, stringBuffer, allowMalformed) {
       this[_chunkedSink] = chunkedSink;
       this[_decoder] = new _Utf8Decoder(stringBuffer, allowMalformed);
       this[_buffer] = stringBuffer;
       super.ByteConversionSink();
     }
@@ skipping 16 matching lines @@
         let accumulated = dart.toString(this[_buffer]);
         this[_chunkedSink].addSlice(accumulated, 0, accumulated.length, isLast);
         this[_buffer].clear();
         return;
       }
       if (isLast)
         this.close();
     }
   }
   dart.defineNamedConstructor(_Utf8ConversionSink, '_');
+  dart.setSignature(_Utf8ConversionSink, {
+    methods: () => ({
+      close: dart.functionType(dart.void, []),
+      add: dart.functionType(dart.void, [core.List$(core.int)]),
+      addSlice: dart.functionType(dart.void, [core.List$(core.int), core.int, core.int, core.bool])
+    })
+  });
   let UNICODE_REPLACEMENT_CHARACTER_RUNE = 65533;
   let UNICODE_BOM_CHARACTER_RUNE = 65279;
   let _allowMalformed = Symbol('_allowMalformed');
   class Utf8Codec extends Encoding {
     Utf8Codec(opts) {
       let allowMalformed = opts && 'allowMalformed' in opts ? opts.allowMalformed : false;
       this[_allowMalformed] = allowMalformed;
       super.Encoding();
     }
     get name() {
       return "utf-8";
     }
     decode(codeUnits, opts) {
       let allowMalformed = opts && 'allowMalformed' in opts ? opts.allowMalformed : null;
       if (allowMalformed == null)
         allowMalformed = this[_allowMalformed];
       return new Utf8Decoder({allowMalformed: allowMalformed}).convert(codeUnits);
     }
     get encoder() {
       return new Utf8Encoder();
     }
     get decoder() {
       return new Utf8Decoder({allowMalformed: this[_allowMalformed]});
     }
   }
+  dart.setSignature(Utf8Codec, {
+    methods: () => ({decode: dart.functionType(core.String, [core.List$(core.int)], {llowMalforme: core.bool})})
+  });
   let UTF8 = dart.const(new Utf8Codec());
   let _fillBuffer = Symbol('_fillBuffer');
   let _writeSurrogate = Symbol('_writeSurrogate');
   class Utf8Encoder extends Converter$(core.String, core.List$(core.int)) {
     Utf8Encoder() {
       super.Converter();
     }
     convert(string, start, end) {
       if (start === void 0)
         start = 0;
@@ skipping 20 matching lines @@
     startChunkedConversion(sink) {
       if (!dart.is(sink, ByteConversionSink)) {
         sink = new ByteConversionSink.from(sink);
       }
       return new _Utf8EncoderSink(dart.as(sink, ByteConversionSink));
     }
     bind(stream) {
       return super.bind(stream);
     }
   }
+  dart.setSignature(Utf8Encoder, {
+    methods: () => ({
+      convert: dart.functionType(core.List$(core.int), [core.String], [core.int, core.int]),
+      startChunkedConversion: dart.functionType(StringConversionSink, [core.Sink$(core.List$(core.int))]),
+      bind: dart.functionType(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) {
@@ skipping 101 matching lines @@
               this[_bufferIndex] = dart.notNull(x) + 1;
               return x;
             }).bind(this)(), 128 | dart.notNull(rune) & 63);
           }
         }
       }
       return stringIndex;
     }
   }
   dart.defineNamedConstructor(_Utf8Encoder, 'withBufferSize');
+  dart.setSignature(_Utf8Encoder, {
+    methods: () => ({
+      [_writeSurrogate]: dart.functionType(core.bool, [core.int, core.int]),
+      [_fillBuffer]: dart.functionType(core.int, [core.String, core.int, core.int])
+    }),
+    statics: () => ({_createBuffer: dart.functionType(core.List$(core.int), [core.int])}),
+    names: ['_createBuffer']
+  });
   _Utf8Encoder._DEFAULT_BYTE_BUFFER_SIZE = 1024;
   class _Utf8EncoderSink extends dart.mixin(_Utf8Encoder, StringConversionSinkMixin) {
     _Utf8EncoderSink(sink) {
       this[_sink] = sink;
       super._Utf8Encoder();
     }
     close() {
       if (this[_carry] != 0) {
         this.addSlice("", 0, 0, true);
         return;
@@ skipping 31 matching lines @@
           }
           start = dart.notNull(start) + 1;
         }
         this[_sink].addSlice(this[_buffer], 0, this[_bufferIndex], isLastSlice);
         this[_bufferIndex] = 0;
       } while (dart.notNull(start) < dart.notNull(end));
       if (isLast)
         this.close();
     }
   }
+  dart.setSignature(_Utf8EncoderSink, {
+    methods: () => ({
+      close: dart.functionType(dart.void, []),
+      addSlice: dart.functionType(dart.void, [core.String, core.int, core.int, core.bool])
+    })
+  });
   class Utf8Decoder extends Converter$(core.List$(core.int), core.String) {
     Utf8Decoder(opts) {
       let allowMalformed = opts && 'allowMalformed' in opts ? opts.allowMalformed : false;
       this[_allowMalformed] = allowMalformed;
       super.Converter();
     }
     convert(codeUnits, start, end) {
       if (start === void 0)
         start = 0;
       if (end === void 0)
@@ skipping 17 matching lines @@
       }
       return stringSink.asUtf8Sink(this[_allowMalformed]);
     }
     bind(stream) {
       return super.bind(stream);
     }
     fuse(next) {
       return super.fuse(next);
     }
   }
+  dart.setSignature(Utf8Decoder, {
+    methods: () => ({
+      convert: dart.functionType(core.String, [core.List$(core.int)], [core.int, core.int]),
+      startChunkedConversion: dart.functionType(ByteConversionSink, [core.Sink$(core.String)]),
+      bind: dart.functionType(async.Stream$(core.String), [async.Stream$(core.List$(core.int))]),
+      fuse: dart.functionType(Converter$(core.List$(core.int), dart.dynamic), [Converter$(core.String, dart.dynamic)])
+    })
+  });
   let _ONE_BYTE_LIMIT = 127;
   let _TWO_BYTE_LIMIT = 2047;
   let _THREE_BYTE_LIMIT = 65535;
   let _FOUR_BYTE_LIMIT = 1114111;
   let _SURROGATE_MASK = 63488;
   let _SURROGATE_TAG_MASK = 64512;
   let _SURROGATE_VALUE_MASK = 1023;
   let _LEAD_SURROGATE_MIN = 55296;
   let _TAIL_SURROGATE_MIN = 56320;
-  // Function _isSurrogate: (int) → bool
   function _isSurrogate(codeUnit) {
     return (dart.notNull(codeUnit) & dart.notNull(_SURROGATE_MASK)) == _LEAD_SURROGATE_MIN;
   }
-  // Function _isLeadSurrogate: (int) → bool
+  dart.fn(_isSurrogate, core.bool, [core.int]);
   function _isLeadSurrogate(codeUnit) {
     return (dart.notNull(codeUnit) & dart.notNull(_SURROGATE_TAG_MASK)) == _LEAD_SURROGATE_MIN;
   }
-  // Function _isTailSurrogate: (int) → bool
+  dart.fn(_isLeadSurrogate, core.bool, [core.int]);
   function _isTailSurrogate(codeUnit) {
     return (dart.notNull(codeUnit) & dart.notNull(_SURROGATE_TAG_MASK)) == _TAIL_SURROGATE_MIN;
   }
-  // Function _combineSurrogatePair: (int, int) → int
+  dart.fn(_isTailSurrogate, core.bool, [core.int]);
   function _combineSurrogatePair(lead, tail) {
     return 65536 + ((dart.notNull(lead) & dart.notNull(_SURROGATE_VALUE_MASK)) << 10) | dart.notNull(tail) & dart.notNull(_SURROGATE_VALUE_MASK);
   }
+  dart.fn(_combineSurrogatePair, core.int, [core.int, core.int]);
   let _isFirstCharacter = Symbol('_isFirstCharacter');
   let _value = Symbol('_value');
   let _expectedUnits = Symbol('_expectedUnits');
   let _extraUnits = Symbol('_extraUnits');
   class _Utf8Decoder extends core.Object {
     _Utf8Decoder(stringSink, allowMalformed) {
       this[_stringSink] = stringSink;
       this[_allowMalformed] = allowMalformed;
       this[_isFirstCharacter] = true;
       this[_value] = 0;
@@ skipping 17 matching lines @@
         this[_extraUnits] = 0;
       }
     }
     convert(codeUnits, startIndex, endIndex) {
       let value = this[_value];
       let expectedUnits = this[_expectedUnits];
       let extraUnits = this[_extraUnits];
       this[_value] = 0;
       this[_expectedUnits] = 0;
       this[_extraUnits] = 0;
-      // Function scanOneByteCharacters: (dynamic, int) → int
       let scanOneByteCharacters = (units, from) => {
         let to = endIndex;
         let mask = _ONE_BYTE_LIMIT;
         for (let i = from; dart.notNull(i) < dart.notNull(to); i = dart.notNull(i) + 1) {
           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);
       };
-      // Function addSingleBytes: (int, int) → void
+      dart.fn(scanOneByteCharacters, core.int, [dart.dynamic, 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));
       }).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;
                 }
                 let unit = codeUnits[core.$get](i);
@@ skipping 76 matching lines @@
           }
           break loop;
         }
       if (dart.notNull(expectedUnits) > 0) {
         this[_value] = value;
         this[_expectedUnits] = expectedUnits;
         this[_extraUnits] = extraUnits;
       }
     }
   }
+  dart.setSignature(_Utf8Decoder, {
+    methods: () => ({
+      close: dart.functionType(dart.void, []),
+      flush: dart.functionType(dart.void, []),
+      convert: dart.functionType(dart.void, [core.List$(core.int), core.int, core.int])
+    })
+  });
   _Utf8Decoder._LIMITS = dart.const(dart.setType([_ONE_BYTE_LIMIT, _TWO_BYTE_LIMIT, _THREE_BYTE_LIMIT, _FOUR_BYTE_LIMIT], core.List$(core.int)));
   let _processed = Symbol('_processed');
   let _computeKeys = Symbol('_computeKeys');
   let _original = Symbol('_original');
-  // Function _convertJsonToDart: (dynamic, (dynamic, dynamic) → dynamic) → dynamic
   function _convertJsonToDart(json, reviver) {
     dart.assert(reviver != null);
-    // Function walk: (dynamic) → dynamic
     let walk = e => {
       if (e == null || typeof e != "object") {
         return e;
       }
       if (Object.getPrototypeOf(e) === Array.prototype) {
         for (let i = 0; dart.notNull(i) < e.length; i = dart.notNull(i) + 1) {
           let item = e[i];
           e[i] = dart.dcall(reviver, i, walk(item));
         }
         return e;
       }
       let map = new _JsonMap(e);
       let processed = map[_processed];
       let keys = map[_computeKeys]();
       for (let i = 0; dart.notNull(i) < dart.notNull(keys[core.$length]); i = dart.notNull(i) + 1) {
         let key = keys[core.$get](i);
         let revived = dart.dcall(reviver, key, walk(e[key]));
         processed[key] = revived;
       }
       map[_original] = processed;
       return map;
     };
+    dart.fn(walk);
     return dart.dcall(reviver, null, walk(json));
   }
-  // Function _convertJsonToDartLazy: (dynamic) → dynamic
+  dart.fn(_convertJsonToDart, dart.dynamic, [dart.dynamic, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]);
   function _convertJsonToDartLazy(object) {
     if (object == null)
       return null;
     if (typeof object != "object") {
       return object;
     }
     if (Object.getPrototypeOf(object) !== Array.prototype) {
       return new _JsonMap(object);
     }
     for (let i = 0; dart.notNull(i) < object.length; i = dart.notNull(i) + 1) {
       let item = object[i];
       object[i] = _convertJsonToDartLazy(item);
     }
     return object;
   }
+  dart.fn(_convertJsonToDartLazy);
   let _data = Symbol('_data');
   let _isUpgraded = Symbol('_isUpgraded');
   let _upgradedMap = Symbol('_upgradedMap');
   let _process = Symbol('_process');
   let _upgrade = Symbol('_upgrade');
   class _JsonMap extends core.Object {
     _JsonMap(original) {
       this[_processed] = _JsonMap._newJavaScriptObject();
       this[_original] = original;
       this[_data] = null;
@@ skipping 20 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](), (each => this.get(each)).bind(this));
+      return new _internal.MappedIterable(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);
         }
       } else {
         this[_upgrade]().set(key, value);
       }
     }
     addAll(other) {
-      other.forEach(((key, value) => {
+      other.forEach(dart.fn(((key, value) => {
         this.set(key, value);
-      }).bind(this));
+      }).bind(this)));
     }
     containsValue(value) {
       if (this[_isUpgraded])
         return this[_upgradedMap].containsValue(value);
       let keys = this[_computeKeys]();
       for (let i = 0; dart.notNull(i) < dart.notNull(keys[core.$length]); i = dart.notNull(i) + 1) {
         let key = keys[core.$get](i);
         if (dart.equals(this.get(key), value))
           return true;
       }
@@ skipping 102 matching lines @@
       return dart.as(Object.keys(object), core.List);
     }
     static _isUnprocessed(object) {
       return typeof object == "undefined";
     }
     static _newJavaScriptObject() {
       return Object.create(null);
     }
   }
   _JsonMap[dart.implements] = () => [collection.LinkedHashMap];
+  dart.setSignature(_JsonMap, {
+    methods: () => ({
+      get: dart.functionType(dart.dynamic, [core.Object]),
+      set: dart.functionType(dart.void, [dart.dynamic, dart.dynamic]),
+      addAll: dart.functionType(dart.void, [core.Map]),
+      containsValue: dart.functionType(core.bool, [core.Object]),
+      containsKey: dart.functionType(core.bool, [core.Object]),
+      putIfAbsent: dart.functionType(dart.dynamic, [dart.dynamic, dart.functionType(dart.dynamic, [])]),
+      remove: dart.functionType(dart.dynamic, [core.Object]),
+      clear: dart.functionType(dart.void, []),
+      forEach: dart.functionType(dart.void, [dart.functionType(dart.void, [dart.dynamic, dart.dynamic])]),
+      toString: dart.functionType(core.String, []),
+      [_computeKeys]: dart.functionType(core.List$(core.String), []),
+      [_upgrade]: dart.functionType(core.Map, []),
+      [_process]: dart.functionType(dart.dynamic, [core.String])
+    }),
+    statics: () => ({
+      _hasProperty: dart.functionType(core.bool, [dart.dynamic, core.String]),
+      _getProperty: dart.functionType(dart.dynamic, [dart.dynamic, core.String]),
+      _setProperty: dart.functionType(dart.dynamic, [dart.dynamic, core.String, dart.dynamic]),
+      _getPropertyNames: dart.functionType(core.List, [dart.dynamic]),
+      _isUnprocessed: dart.functionType(core.bool, [dart.dynamic]),
+      _newJavaScriptObject: dart.functionType(dart.dynamic, [])
+    }),
+    names: ['_hasProperty', '_getProperty', '_setProperty', '_getPropertyNames', '_isUnprocessed', '_newJavaScriptObject']
+  });
   let _parent = Symbol('_parent');
   class _JsonMapKeyIterable extends _internal.ListIterable {
     _JsonMapKeyIterable(parent) {
       this[_parent] = parent;
       super.ListIterable();
     }
     get [core.$length]() {
       return this[_parent].length;
     }
     [core.$elementAt](index) {
       return this[_parent][_isUpgraded] ? dart.as(this[_parent].keys[core.$elementAt](index), core.String) : this[_parent][_computeKeys]()[core.$get](index);
     }
     get [core.$iterator]() {
       return this[_parent][_isUpgraded] ? this[_parent].keys[core.$iterator] : this[_parent][_computeKeys]()[core.$iterator];
     }
     [core.$contains](key) {
       return this[_parent].containsKey(key);
     }
   }
+  dart.setSignature(_JsonMapKeyIterable, {
+    methods: () => ({
+      [core.$elementAt]: dart.functionType(core.String, [core.int]),
+      [core.$contains]: dart.functionType(core.bool, [core.Object])
+    })
+  });
   class _JsonDecoderSink extends _StringSinkConversionSink {
     _JsonDecoderSink(reviver, sink) {
       this[_reviver] = reviver;
       this[_sink] = sink;
       super._StringSinkConversionSink(new core.StringBuffer());
     }
     close() {
       super.close();
       let buffer = dart.as(this[_stringSink], core.StringBuffer);
       let accumulated = dart.toString(buffer);
       buffer.clear();
       let decoded = _parseJson(accumulated, this[_reviver]);
       this[_sink].add(decoded);
       this[_sink].close();
     }
   }
+  dart.setSignature(_JsonDecoderSink, {
+    methods: () => ({close: dart.functionType(dart.void, [])})
+  });
   // Exports:
   exports.Codec$ = Codec$;
   exports.Codec = Codec;
   exports.Encoding = Encoding;
   exports.AsciiCodec = AsciiCodec;
   exports.ASCII = ASCII;
   exports.Converter$ = Converter$;
   exports.Converter = Converter;
   exports.AsciiEncoder = AsciiEncoder;
   exports.StringConversionSinkMixin = StringConversionSinkMixin;
@@ skipping 20 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);