implement mixins in subtype checks, more codegen fixes

lib/runtime/dart/convert.js

 var convert;
 (function(exports) {
   'use strict';
   let ASCII = new AsciiCodec();
   let _ASCII_MASK = 127;
   let _allowInvalid = Symbol('_allowInvalid');
   let _nameToEncoding = Symbol('_nameToEncoding');
   let Codec$ = dart.generic(function(S, T) {
     class Codec extends core.Object {
       Codec() {
       }
       encode(input) {
         return this.encoder.convert(input);
       }
       decode(encoded) {
         return this.decoder.convert(encoded);
       }
       fuse(other) {
         return new (_FusedCodec$(S, T, dynamic))(this, other);
       }
       get inverted() {
         return new (_InvertedCodec$(T, S))(this);
       }
     }
     return Codec;
   });
-  let Codec = Codec$(dart.dynamic, dart.dynamic);
+  let Codec = Codec$();
   class Encoding extends Codec$(core.String, core.List$(core.int)) {
     Encoding() {
       super.Codec();
     }
     decodeStream(byteStream) {
       return dart.as(byteStream.transform(dart.as(this.decoder, async.StreamTransformer$(core.List$(core.int), dynamic))).fold(new core.StringBuffer(), (buffer, string) => dart.dinvoke(buffer, 'write', string), buffer).then((buffer) => dart.dinvoke(buffer, 'toString')), async.Future$(core.String));
     }
     static getByName(name) {
       if (name == null)
         return null;
@@ skipping 44 matching lines @@
       startChunkedConversion(sink) {
         throw new core.UnsupportedError(`This converter does not support chunked conversions: ${this}`);
       }
       bind(source) {
         return new async.Stream.eventTransformed(source, ((sink) => new _ConverterStreamEventSink(this, sink)).bind(this));
       }
     }
     Converter[dart.implements] = () => [async.StreamTransformer];
     return Converter;
   });
-  let Converter = Converter$(dart.dynamic, dart.dynamic);
+  let Converter = Converter$();
   class _UnicodeSubsetEncoder extends Converter$(core.String, core.List$(core.int)) {
     _UnicodeSubsetEncoder(subsetMask) {
       this[_subsetMask] = subsetMask;
       super.Converter();
     }
     convert(string, start, end) {
       if (start === void 0)
         start = 0;
       if (end === void 0)
         end = null;
@@ skipping 33 matching lines @@
       return this.addSlice(str, 0, str.length, false);
     }
     asUtf8Sink(allowMalformed) {
       return new _Utf8ConversionSink(this, allowMalformed);
     }
     asStringSink() {
       return new _StringConversionSinkAsStringSinkAdapter(this);
     }
   }
   StringConversionSinkMixin[dart.implements] = () => [StringConversionSink];
-  class StringConversionSinkBase extends StringConversionSinkMixin {
-  }
+  class StringConversionSinkBase extends StringConversionSinkMixin {}
   class _UnicodeSubsetEncoderSink extends StringConversionSinkBase {
     _UnicodeSubsetEncoderSink(subsetMask, sink$) {
       this[_subsetMask] = subsetMask;
       this[_sink] = sink$;
       super.StringConversionSinkBase();
     }
     close() {
       this[_sink].close();
     }
     addSlice(source, start, end, isLast) {
@@ skipping 77 matching lines @@
       ChunkedConversionSink() {
       }
       withCallback(callback) {
         return new _SimpleCallbackSink(callback);
       }
     }
     ChunkedConversionSink[dart.implements] = () => [core.Sink$(T)];
     dart.defineNamedConstructor(ChunkedConversionSink, 'withCallback');
     return ChunkedConversionSink;
   });
-  let ChunkedConversionSink = ChunkedConversionSink$(dart.dynamic);
+  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);
     }
@@ skipping 109 matching lines @@
       v = dart.notNull(v) >> 8;
       v = dart.notNull(v) >> 16;
       v = dart.notNull(v) + 1;
       return v;
     }
     close() {
       this[_callback](this[_buffer].sublist(0, this[_bufferIndex]));
     }
   }
   _ByteCallbackSink._INITIAL_BUFFER_SIZE = 1024;
+  let _ChunkedConversionCallback$ = dart.generic(function(T) {
+    class _ChunkedConversionCallback extends core.Function {}
+    return _ChunkedConversionCallback;
+  });
+  let _ChunkedConversionCallback = _ChunkedConversionCallback$();
   let _accumulated = Symbol('_accumulated');
   let _SimpleCallbackSink$ = dart.generic(function(T) {
     class _SimpleCallbackSink extends ChunkedConversionSink$(T) {
       _SimpleCallbackSink(callback$) {
         this[_accumulated] = new core.List$(T).from([]);
         this[_callback] = callback$;
         super.ChunkedConversionSink();
       }
       add(chunk) {
         this[_accumulated].add(chunk);
       }
       close() {
         this[_callback](this[_accumulated]);
       }
     }
     return _SimpleCallbackSink;
   });
-  let _SimpleCallbackSink = _SimpleCallbackSink$(dart.dynamic);
+  let _SimpleCallbackSink = _SimpleCallbackSink$();
   let _EventSinkAdapter$ = dart.generic(function(T) {
     class _EventSinkAdapter extends core.Object {
       _EventSinkAdapter(sink$) {
         this[_sink] = sink$;
       }
       add(data) {
         return this[_sink].add(data);
       }
       close() {
         return this[_sink].close();
       }
     }
     _EventSinkAdapter[dart.implements] = () => [ChunkedConversionSink$(T)];
     return _EventSinkAdapter;
   });
-  let _EventSinkAdapter = _EventSinkAdapter$(dart.dynamic);
+  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) {
         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)];
     return _ConverterStreamEventSink;
   });
-  let _ConverterStreamEventSink = _ConverterStreamEventSink$(dart.dynamic, dart.dynamic);
+  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();
       }
     }
     return _FusedCodec;
   });
-  let _FusedCodec = _FusedCodec$(dart.dynamic, dart.dynamic, dart.dynamic);
+  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];
       }
     }
     return _InvertedCodec;
   });
-  let _InvertedCodec = _InvertedCodec$(dart.dynamic, dart.dynamic);
+  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) {
         return dart.as(this[_second].convert(this[_first].convert(input)), T);
       }
       startChunkedConversion(sink) {
         return this[_first].startChunkedConversion(this[_second].startChunkedConversion(sink));
       }
     }
     return _FusedConverter;
   });
-  let _FusedConverter = _FusedConverter$(dart.dynamic, dart.dynamic, dart.dynamic);
+  let _FusedConverter = _FusedConverter$();
   let HTML_ESCAPE = new HtmlEscape();
   let _$ = Symbol('_');
   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;
@@ skipping 120 matching lines @@
   }
   class JsonCyclicError extends JsonUnsupportedObjectError {
     JsonCyclicError(object) {
       super.JsonUnsupportedObjectError(object);
     }
     toString() {
       return "Cyclic error in JSON stringify";
     }
   }
   let JSON = new JsonCodec();
+  class _Reviver extends core.Function {}
+  class _ToEncodable extends core.Function {}
   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 813 matching lines @@
   }
   dart.defineNamedConstructor(StringConversionSink, 'withCallback');
   dart.defineNamedConstructor(StringConversionSink, 'from');
   dart.defineNamedConstructor(StringConversionSink, 'fromStringSink');
   class ClosableStringSink extends core.StringSink {
     fromStringSink(sink, onClose) {
       return new _ClosableStringSink(sink, onClose);
     }
   }
   dart.defineNamedConstructor(ClosableStringSink, 'fromStringSink');
+  class _StringSinkCloseCallback extends core.Function {}
   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);
@@ skipping 854 matching lines @@
       buffer.clear();
       let decoded = _parseJson(accumulated, this[_reviver]);
       this[_sink].add(decoded);
       this[_sink].close();
     }
   }
   // Exports:
   exports.ASCII = ASCII;
   exports.AsciiCodec = AsciiCodec;
   exports.Encoding = Encoding;
+  exports.Codec$ = Codec$;
   exports.Codec = Codec;
-  exports.Codec$ = Codec$;
+  exports.Converter$ = Converter$;
   exports.Converter = Converter;
-  exports.Converter$ = Converter$;
   exports.AsciiEncoder = AsciiEncoder;
   exports.StringConversionSinkBase = StringConversionSinkBase;
   exports.StringConversionSinkMixin = StringConversionSinkMixin;
   exports.AsciiDecoder = AsciiDecoder;
   exports.ByteConversionSinkBase = ByteConversionSinkBase;
   exports.ByteConversionSink = ByteConversionSink;
+  exports.ChunkedConversionSink$ = ChunkedConversionSink$;
   exports.ChunkedConversionSink = ChunkedConversionSink;
-  exports.ChunkedConversionSink$ = ChunkedConversionSink$;
   exports.HTML_ESCAPE = HTML_ESCAPE;
   exports.HtmlEscapeMode = HtmlEscapeMode;
   exports.HtmlEscape = HtmlEscape;
   exports.JsonUnsupportedObjectError = JsonUnsupportedObjectError;
   exports.JsonCyclicError = JsonCyclicError;
   exports.JSON = JSON;
   exports.JsonCodec = JsonCodec;
   exports.JsonEncoder = JsonEncoder;
   exports.JsonUtf8Encoder = JsonUtf8Encoder;
   exports.JsonDecoder = JsonDecoder;
   exports.LATIN1 = LATIN1;
   exports.Latin1Codec = Latin1Codec;
   exports.Latin1Encoder = Latin1Encoder;
   exports.Latin1Decoder = Latin1Decoder;
   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.UTF8 = UTF8;
   exports.Utf8Codec = Utf8Codec;
   exports.Utf8Encoder = Utf8Encoder;
   exports.Utf8Decoder = Utf8Decoder;
 })(convert || (convert = {}));