add checks needed for covariant generics, and List<E>

lib/runtime/dart/convert.js

 var convert;
 (function(exports) {
   'use strict';
   let ASCII = dart.const(new AsciiCodec());
   let _ASCII_MASK = 127;
   let _allowInvalid = Symbol('_allowInvalid');
   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);
       }
     }
     return Codec;
   });
   let Codec = Codec$();
   class Encoding extends Codec$(core.String, core.List$(core.int)) {
@@ skipping 44 matching lines @@
     get decoder() {
       return this[_allowInvalid] ? dart.const(new AsciiDecoder({allowInvalid: true})) : dart.const(new AsciiDecoder({allowInvalid: false}));
     }
   }
   let _subsetMask = Symbol('_subsetMask');
   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) {
         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];
@@ skipping 281 matching lines @@
   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]);
       }
     }
     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)];
     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();
       }
@@ skipping 42 matching lines @@
   });
   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) {
         return this[_first].startChunkedConversion(this[_second].startChunkedConversion(sink));
       }
     }
     return _FusedConverter;
   });
   let _FusedConverter = _FusedConverter$();
   let HTML_ESCAPE = dart.const(new HtmlEscape());
@@ skipping 1921 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.UTF8 = UTF8;
   exports.Utf8Codec = Utf8Codec;
   exports.Utf8Encoder = Utf8Encoder;
   exports.Utf8Decoder = Utf8Decoder;
 })(convert || (convert = {}));