Handle dynamic as bottom inside of function type reps

lib/runtime/dart/convert.js

 dart_library.library('dart/convert', null, /* Imports */[
   "dart_runtime/dart",
   'dart/core',
   'dart/async',
   'dart/typed_data',
   'dart/_internal',
   'dart/collection'
 ], /* Lazy imports */[
 ], function(exports, dart, core, async, typed_data, _internal, collection) {
   'use strict';
   let dartx = dart.dartx;
   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, core.Object));
-        return new (_FusedCodec$(S, T, core.Object))(this, 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, {
       constructors: () => ({Codec: [Codec$(S, T), []]}),
       methods: () => ({
         encode: [T, [S]],
         decode: [S, [T]],
-        fuse: [Codec$(S, core.Object), [Codec$(T, core.Object)]]
+        fuse: [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(), dart.fn((buffer, string) => ((() => {
         dart.dsend(buffer, 'write', string);
         return buffer;
-      })()))).then(dart.fn(buffer => dart.toString(buffer), core.String, [core.Object])), 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[dartx.toLowerCase]();
       return Encoding._nameToEncoding.get(name);
     }
   }
   dart.setSignature(Encoding, {
     constructors: () => ({Encoding: [Encoding, []]}),
@@ skipping 32 matching lines @@
     constructors: () => ({AsciiCodec: [AsciiCodec, [], {allowInvalid: core.bool}]}),
     methods: () => ({decode: [core.String, [core.List$(core.int)], {allowInvalid: 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, core.Object));
-        return new (_FusedConverter$(S, T, core.Object))(this, 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 async.Stream$(T).eventTransformed(source, dart.fn(sink => new _ConverterStreamEventSink(this, sink), _ConverterStreamEventSink, [async.EventSink]));
       }
     }
     Converter[dart.implements] = () => [async.StreamTransformer$(S, T)];
     dart.setSignature(Converter, {
       constructors: () => ({Converter: [Converter$(S, T), []]}),
       methods: () => ({
-        fuse: [Converter$(S, core.Object), [Converter$(T, core.Object)]],
+        fuse: [Converter$(S, dart.dynamic), [Converter$(T, dart.dynamic)]],
         startChunkedConversion: [ChunkedConversionSink, [core.Sink$(T)]],
         bind: [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) {
@@ skipping 658 matching lines @@
     }
     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, {
-    constructors: () => ({JsonUnsupportedObjectError: [JsonUnsupportedObjectError, [core.Object], {cause: core.Object}]})
+    constructors: () => ({JsonUnsupportedObjectError: [JsonUnsupportedObjectError, [dart.dynamic], {cause: dart.dynamic}]})
   });
   class JsonCyclicError extends JsonUnsupportedObjectError {
     JsonCyclicError(object) {
       super.JsonUnsupportedObjectError(object);
     }
     toString() {
       return "Cyclic error in JSON stringify";
     }
   }
   dart.setSignature(JsonCyclicError, {
@@ skipping 35 matching lines @@
     }
     get decoder() {
       if (this[_reviver] == null)
         return dart.const(new JsonDecoder());
       return new JsonDecoder(this[_reviver]);
     }
   }
   dart.defineNamedConstructor(JsonCodec, 'withReviver');
   dart.setSignature(JsonCodec, {
     constructors: () => ({
-      JsonCodec: [JsonCodec, [], {reviver: dart.functionType(core.Object, [dart.bottom, dart.bottom]), toEncodable: dart.functionType(core.Object, [dart.bottom])}],
-      withReviver: [JsonCodec, [dart.functionType(core.Object, [dart.bottom, dart.bottom])]]
+      JsonCodec: [JsonCodec, [], {reviver: dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]), toEncodable: dart.functionType(dart.dynamic, [dart.dynamic])}],
+      withReviver: [JsonCodec, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]]
     }),
     methods: () => ({
-      decode: [core.Object, [core.String], {reviver: dart.functionType(core.Object, [dart.bottom, dart.bottom])}],
-      encode: [core.String, [core.Object], {toEncodable: dart.functionType(core.Object, [dart.bottom])}]
+      decode: [dart.dynamic, [core.String], {reviver: dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])}],
+      encode: [core.String, [core.Object], {toEncodable: dart.functionType(dart.dynamic, [dart.dynamic])}]
     })
   });
   let JSON = dart.const(new JsonCodec());
-  let _Reviver = dart.typedef('_Reviver', () => dart.functionType(core.Object, [dart.bottom, dart.bottom]));
-  let _ToEncodable = dart.typedef('_ToEncodable', () => dart.functionType(core.Object, [dart.bottom]));
+  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();
     }
     withIndent(indent, toEncodable) {
       if (toEncodable === void 0)
@@ skipping 26 matching lines @@
   dart.defineNamedConstructor(JsonEncoder, 'withIndent');
   dart.setSignature(JsonEncoder, {
     constructors: () => ({
       JsonEncoder: [JsonEncoder, [], [dart.functionType(core.Object, [core.Object])]],
       withIndent: [JsonEncoder, [core.String], [dart.functionType(core.Object, [core.Object])]]
     }),
     methods: () => ({
       convert: [core.String, [core.Object]],
       startChunkedConversion: [ChunkedConversionSink$(core.Object), [core.Sink$(core.String)]],
       bind: [async.Stream$(core.String), [async.Stream$(core.Object)]],
-      fuse: [Converter$(core.Object, core.Object), [Converter$(core.String, core.Object)]]
+      fuse: [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;
@@ skipping 21 matching lines @@
     convert(object) {
       let bytes = dart.list([], core.List$(core.int));
       let addChunk = (chunk, start, end) => {
         if (dart.notNull(start) > 0 || dart.notNull(end) < dart.notNull(chunk.length)) {
           let length = dart.notNull(end) - dart.notNull(start);
           chunk = typed_data.Uint8List.view(chunk.buffer, dart.notNull(chunk.offsetInBytes) + dart.notNull(start), length);
         }
         bytes[dartx.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);
+      _JsonUtf8Stringifier.stringify(object, this[_indent], dart.as(this[_toEncodable$], dart.functionType(dart.dynamic, [core.Object])), this[_bufferSize], addChunk);
       if (bytes[dartx.length] == 1)
         return bytes[dartx.get](0);
       let length = 0;
       for (let i = 0; dart.notNull(i) < dart.notNull(bytes[dartx.length]); i = dart.notNull(i) + 1) {
         length = dart.notNull(length) + dart.notNull(bytes[dartx.get](i)[dartx.length]);
       }
       let result = typed_data.Uint8List.new(length);
       for (let i = 0, offset = 0; dart.notNull(i) < dart.notNull(bytes[dartx.length]); i = dart.notNull(i) + 1) {
         let byteList = bytes[dartx.get](i);
         let end = dart.notNull(offset) + dart.notNull(byteList[dartx.length]);
@@ 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, {
-    constructors: () => ({JsonUtf8Encoder: [JsonUtf8Encoder, [], [core.String, dart.functionType(core.Object, [core.Object]), core.int]]}),
+    constructors: () => ({JsonUtf8Encoder: [JsonUtf8Encoder, [], [core.String, dart.functionType(dart.dynamic, [core.Object]), core.int]]}),
     methods: () => ({
       convert: [core.List$(core.int), [core.Object]],
       startChunkedConversion: [ChunkedConversionSink$(core.Object), [core.Sink$(core.List$(core.int))]],
       bind: [async.Stream$(core.List$(core.int)), [async.Stream$(core.Object)]],
-      fuse: [Converter$(core.Object, core.Object), [Converter$(core.List$(core.int), core.Object)]]
+      fuse: [Converter$(core.Object, dart.dynamic), [Converter$(core.List$(core.int), dart.dynamic)]]
     }),
     statics: () => ({_utf8Encode: [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 (dart.notNull(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(core.Object, [dart.bottom])), this[_indent]);
+      _JsonStringStringifier.printOn(o, stringSink, dart.as(this[_toEncodable$], dart.functionType(dart.dynamic, [dart.dynamic])), this[_indent]);
       stringSink.close();
     }
     close() {}
   }
   dart.setSignature(_JsonEncoderSink, {
     constructors: () => ({_JsonEncoderSink: [_JsonEncoderSink, [StringConversionSink, core.Function, core.String]]}),
     methods: () => ({
       add: [dart.void, [core.Object]],
       close: [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 (dart.notNull(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(core.Object, [core.Object])), this[_bufferSize], dart.bind(this, _addChunk));
+      _JsonUtf8Stringifier.stringify(object, this[_indent], dart.as(this[_toEncodable$], dart.functionType(dart.dynamic, [core.Object])), this[_bufferSize], dart.bind(this, _addChunk));
       this[_sink].close();
     }
     close() {
       if (!dart.notNull(this[_isDone])) {
         this[_isDone] = true;
         this[_sink].close();
       }
     }
   }
   dart.setSignature(_JsonUtf8EncoderSink, {
@@ skipping 15 matching lines @@
       return _parseJson(input, this[_reviver]);
     }
     startChunkedConversion(sink) {
       return new _JsonDecoderSink(this[_reviver], sink);
     }
     bind(stream) {
       return super.bind(stream);
     }
   }
   dart.setSignature(JsonDecoder, {
-    constructors: () => ({JsonDecoder: [JsonDecoder, [], [dart.functionType(core.Object, [dart.bottom, dart.bottom])]]}),
+    constructors: () => ({JsonDecoder: [JsonDecoder, [], [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]]}),
     methods: () => ({
-      convert: [core.Object, [core.String]],
+      convert: [dart.dynamic, [core.String]],
       startChunkedConversion: [StringConversionSink, [core.Sink$(core.Object)]],
       bind: [async.Stream$(core.Object), [async.Stream$(core.String)]]
     })
   });
   function _parseJson(source, reviver) {
     if (!(typeof source == 'string'))
       throw new core.ArgumentError(source);
     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);
     }
   }
-  dart.fn(_parseJson, core.Object, [core.String, dart.functionType(core.Object, [dart.bottom, dart.bottom])]);
+  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, [core.Object]);
+  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] = 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);
@@ skipping 135 matching lines @@
     }
     writeMap(map) {
       this.writeString('{');
       let separator = '"';
       map.forEach(dart.fn((key, value) => {
         this.writeString(separator);
         separator = ',"';
         this.writeStringContent(key);
         this.writeString('":');
         this.writeObject(value);
-      }, core.Object, [core.String, core.Object]));
+      }, dart.dynamic, [core.String, dart.dynamic]));
       this.writeString('}');
     }
   }
   dart.setSignature(_JsonStringifier, {
     constructors: () => ({_JsonStringifier: [_JsonStringifier, [dart.functionType(core.Object, [core.Object])]]}),
     methods: () => ({
       writeStringContent: [dart.void, [core.String]],
-      [_checkCycle]: [dart.void, [core.Object]],
-      [_removeSeen]: [dart.void, [core.Object]],
-      writeObject: [dart.void, [core.Object]],
-      writeJsonValue: [core.bool, [core.Object]],
+      [_checkCycle]: [dart.void, [dart.dynamic]],
+      [_removeSeen]: [dart.void, [dart.dynamic]],
+      writeObject: [dart.void, [dart.dynamic]],
+      writeJsonValue: [core.bool, [dart.dynamic]],
       writeList: [dart.void, [core.List]],
       writeMap: [dart.void, [core.Map$(core.String, core.Object)]]
     }),
     statics: () => ({hexDigit: [core.int, [core.int]]}),
     names: ['hexDigit']
   });
   _JsonStringifier.BACKSPACE = 8;
   _JsonStringifier.TAB = 9;
   _JsonStringifier.NEWLINE = 10;
   _JsonStringifier.CARRIAGE_RETURN = 13;
@@ skipping 41 matching lines @@
         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;
-        }, core.Object, [core.String, core.Object]));
+        }, 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: () => ({
@@ skipping 27 matching lines @@
       this[_sink].write(string);
     }
     writeStringSlice(string, start, end) {
       this[_sink].write(string[dartx.substring](start, end));
     }
     writeCharCode(charCode) {
       this[_sink].writeCharCode(charCode);
     }
   }
   dart.setSignature(_JsonStringStringifier, {
-    constructors: () => ({_JsonStringStringifier: [_JsonStringStringifier, [core.StringSink, core.Object]]}),
+    constructors: () => ({_JsonStringStringifier: [_JsonStringStringifier, [core.StringSink, dart.dynamic]]}),
     methods: () => ({
       writeNumber: [dart.void, [core.num]],
       writeString: [dart.void, [core.String]],
       writeStringSlice: [dart.void, [core.String, core.int, core.int]],
       writeCharCode: [dart.void, [core.int]]
     }),
     statics: () => ({
-      stringify: [core.String, [core.Object, dart.functionType(core.Object, [dart.bottom]), core.String]],
-      printOn: [dart.void, [core.Object, core.StringSink, dart.functionType(core.Object, [dart.bottom]), core.String]]
+      stringify: [core.String, [dart.dynamic, dart.functionType(dart.dynamic, [dart.dynamic]), core.String]],
+      printOn: [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)
@@ skipping 97 matching lines @@
         this.index = 0;
       }
       this.buffer.set((() => {
         let x = this.index;
         this.index = dart.notNull(x) + 1;
         return x;
       })(), byte);
     }
   }
   dart.setSignature(_JsonUtf8Stringifier, {
-    constructors: () => ({_JsonUtf8Stringifier: [_JsonUtf8Stringifier, [core.Object, core.int, core.Function]]}),
+    constructors: () => ({_JsonUtf8Stringifier: [_JsonUtf8Stringifier, [dart.dynamic, core.int, core.Function]]}),
     methods: () => ({
       flush: [dart.void, []],
       writeNumber: [dart.void, [core.num]],
       writeAsciiString: [dart.void, [core.String]],
       writeString: [dart.void, [core.String]],
       writeStringSlice: [dart.void, [core.String, core.int, core.int]],
       writeCharCode: [dart.void, [core.int]],
       writeMultiByteCharCode: [dart.void, [core.int]],
       writeFourByteCharCode: [dart.void, [core.int]],
       writeByte: [dart.void, [core.int]]
     }),
-    statics: () => ({stringify: [dart.void, [core.Object, core.List$(core.int), dart.functionType(core.Object, [core.Object]), core.int, dart.functionType(dart.void, [typed_data.Uint8List, core.int, core.int])]]}),
+    statics: () => ({stringify: [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[dartx.length];
@@ skipping 13 matching lines @@
           this.index = end;
         } else {
           for (let i = 0; dart.notNull(i) < dart.notNull(indentLength); i = dart.notNull(i) + 1) {
             this.writeByte(indent[dartx.get](i));
           }
         }
       }
     }
   }
   dart.setSignature(_JsonUtf8StringifierPretty, {
-    constructors: () => ({_JsonUtf8StringifierPretty: [_JsonUtf8StringifierPretty, [core.Object, core.List$(core.int), core.Object, core.Object]]}),
+    constructors: () => ({_JsonUtf8StringifierPretty: [_JsonUtf8StringifierPretty, [dart.dynamic, core.List$(core.int), dart.dynamic, dart.dynamic]]}),
     methods: () => ({writeIndentation: [dart.void, [core.int]]})
   });
   let __CastType0 = dart.typedef('__CastType0', () => dart.functionType(core.Object, [core.Object]));
-  let __CastType2 = dart.typedef('__CastType2', () => dart.functionType(core.Object, [dart.bottom]));
-  let __CastType4 = dart.typedef('__CastType4', () => 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) {
@@ skipping 797 matching lines @@
     fuse(next) {
       return super.fuse(next);
     }
   }
   dart.setSignature(Utf8Decoder, {
     constructors: () => ({Utf8Decoder: [Utf8Decoder, [], {allowMalformed: core.bool}]}),
     methods: () => ({
       convert: [core.String, [core.List$(core.int)], [core.int, core.int]],
       startChunkedConversion: [ByteConversionSink, [core.Sink$(core.String)]],
       bind: [async.Stream$(core.String), [async.Stream$(core.List$(core.int))]],
-      fuse: [Converter$(core.List$(core.int), core.Object), [Converter$(core.String, core.Object)]]
+      fuse: [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;
@@ skipping 54 matching lines @@
       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);
       };
-      dart.fn(scanOneByteCharacters, core.int, [core.Object, core.int]);
+      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(core.String.fromCharCodes(codeUnits, from, to));
       };
       dart.fn(addSingleBytes, dart.void, [core.int, core.int]);
       let i = startIndex;
       loop:
         while (true) {
           multibyte:
@@ skipping 121 matching lines @@
         let key = keys[dartx.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));
   }
-  dart.fn(_convertJsonToDart, core.Object, [core.Object, dart.functionType(core.Object, [dart.bottom, dart.bottom])]);
+  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) {
@@ skipping 179 matching lines @@
     }
     static _isUnprocessed(object) {
       return typeof object == "undefined";
     }
     static _newJavaScriptObject() {
       return Object.create(null);
     }
   }
   _JsonMap[dart.implements] = () => [collection.LinkedHashMap];
   dart.setSignature(_JsonMap, {
-    constructors: () => ({_JsonMap: [_JsonMap, [core.Object]]}),
+    constructors: () => ({_JsonMap: [_JsonMap, [dart.dynamic]]}),
     methods: () => ({
-      get: [core.Object, [core.Object]],
-      set: [dart.void, [core.Object, core.Object]],
+      get: [dart.dynamic, [core.Object]],
+      set: [dart.void, [dart.dynamic, dart.dynamic]],
       addAll: [dart.void, [core.Map]],
       containsValue: [core.bool, [core.Object]],
       containsKey: [core.bool, [core.Object]],
-      putIfAbsent: [core.Object, [core.Object, dart.functionType(core.Object, [])]],
-      remove: [core.Object, [core.Object]],
+      putIfAbsent: [dart.dynamic, [dart.dynamic, dart.functionType(dart.dynamic, [])]],
+      remove: [dart.dynamic, [core.Object]],
       clear: [dart.void, []],
-      forEach: [dart.void, [dart.functionType(dart.void, [dart.bottom, dart.bottom])]],
+      forEach: [dart.void, [dart.functionType(dart.void, [dart.dynamic, dart.dynamic])]],
       [_computeKeys]: [core.List$(core.String), []],
       [_upgrade]: [core.Map, []],
-      [_process]: [core.Object, [core.String]]
+      [_process]: [dart.dynamic, [core.String]]
     }),
     statics: () => ({
-      _hasProperty: [core.bool, [core.Object, core.String]],
-      _getProperty: [core.Object, [core.Object, core.String]],
-      _setProperty: [core.Object, [core.Object, core.String, core.Object]],
-      _getPropertyNames: [core.List, [core.Object]],
-      _isUnprocessed: [core.bool, [core.Object]],
-      _newJavaScriptObject: [core.Object, []]
+      _hasProperty: [core.bool, [dart.dynamic, core.String]],
+      _getProperty: [dart.dynamic, [dart.dynamic, core.String]],
+      _setProperty: [dart.dynamic, [dart.dynamic, core.String, dart.dynamic]],
+      _getPropertyNames: [core.List, [dart.dynamic]],
+      _isUnprocessed: [core.bool, [dart.dynamic]],
+      _newJavaScriptObject: [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 length() {
@@ skipping 66 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;
 });