Use the dart2js patch for dart:convert to get latest type fixes

pkg/dev_compiler/tool/input_sdk/patch/convert_patch.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // Patch file for dart:convert library.
 
 import 'dart:_js_helper' show argumentErrorValue, patch;
 import 'dart:_foreign_helper' show JS;
 import 'dart:_interceptors' show JSExtendableArray;
 import 'dart:_internal' show MappedIterable, ListIterable;
@@ skipping 105 matching lines @@
     // reference to the list, but the compiler will likely never be able to
     // tell that this instance of the list cannot have its length changed by
     // the reviver even though it later will be passed to the reviver at the
     // outer level.
     var item = JS('', '#[#]', object, i);
     JS('', '#[#]=#', object, i, _convertJsonToDartLazy(item));
   }
   return object;
 }
 
-class _JsonMap implements LinkedHashMap {
+class _JsonMap implements Map<String, dynamic> {
   // The original JavaScript object remains unchanged until
   // the map is eventually upgraded, in which case we null it
   // out to reclaim the memory used by it.
   var _original;
 
   // We keep track of the map entries that we have already
   // processed by adding them to a separate JavaScript object.
   var _processed = _newJavaScriptObject();
 
   // If the data slot isn't null, it represents either the list
@@ skipping 12 matching lines @@
       if (_isUnprocessed(result)) result = _process(key);
       return result;
     }
   }
 
   int get length => _isUpgraded ? _upgradedMap.length : _computeKeys().length;
 
   bool get isEmpty => length == 0;
   bool get isNotEmpty => length > 0;
 
-  Iterable get keys {
+  Iterable<String> get keys {
     if (_isUpgraded) return _upgradedMap.keys;
     return new _JsonMapKeyIterable(this);
   }
 
   Iterable get values {
     if (_isUpgraded) return _upgradedMap.values;
     return new MappedIterable(_computeKeys(), (each) => this[each]);
   }
 
   operator []=(key, value) {
@@ skipping 103 matching lines @@
 
   List<String> _computeKeys() {
     assert(!_isUpgraded);
     List keys = _data;
     if (keys == null) {
       keys = _data = _getPropertyNames(_original);
     }
     return JS('JSExtendableArray', '#', keys);
   }
 
-  Map _upgrade() {
+  Map<String, dynamic> _upgrade() {
     if (_isUpgraded) return _upgradedMap;
 
     // Copy all the (key, value) pairs to a freshly allocated
     // linked hash map thus preserving the ordering.
-    Map result = {};
+    Map result = <String, dynamic>{};

[vsm, 2017/05/24 00:02:18]

If we have Map here, the static type of result is Map<dynamic, dynamic>,
resulting in a runtime check below.

     List<String> keys = _computeKeys();
     for (int i = 0; i < keys.length; i++) {
       String key = keys[i];
       result[key] = this[key];
     }
 
     // We only upgrade when we need to extend the map, so we can
     // safely force a concurrent modification error in case
     // someone is iterating over the map here.
     if (keys.isEmpty) {
@@ skipping 25 matching lines @@
   static _getProperty(object, String key) => JS('', '#[#]', object, key);
   static _setProperty(object, String key, value) =>
       JS('', '#[#]=#', object, key, value);
   static List _getPropertyNames(object) =>
       JS('JSExtendableArray', 'Object.keys(#)', object);
   static bool _isUnprocessed(object) =>
       JS('bool', 'typeof(#)=="undefined"', object);
   static _newJavaScriptObject() => JS('=Object', 'Object.create(null)');
 }
 
-class _JsonMapKeyIterable extends ListIterable {
+class _JsonMapKeyIterable extends ListIterable<String> {
   final _JsonMap _parent;
 
   _JsonMapKeyIterable(this._parent);
 
   int get length => _parent.length;
 
   String elementAt(int index) {
     return _parent._isUpgraded
         ? _parent.keys.elementAt(index)
         : _parent._computeKeys()[index];
   }
 
   /// Although [ListIterable] defines its own iterator, we return the iterator
   /// of the underlying list [_keys] in order to propagate
   /// [ConcurrentModificationError]s.
-  Iterator get iterator {
+  Iterator<String> get iterator {
     return _parent._isUpgraded
         ? _parent.keys.iterator
         : _parent._computeKeys().iterator;
   }
 
   /// Delegate to [parent.containsKey] to ensure the performance expected
   /// from [Map.keys.containsKey].
   bool contains(Object key) => _parent.containsKey(key);
 }
 
 @patch
 class JsonDecoder {
   @patch
   StringConversionSink startChunkedConversion(Sink<Object> sink) {
     return new _JsonDecoderSink(_reviver, sink);
   }
 }
 
 /**
  * Implements the chunked conversion from a JSON string to its corresponding
  * object.
  *
  * The sink only creates one object, but its input can be chunked.
  */
 // TODO(floitsch): don't accumulate everything before starting to decode.
 class _JsonDecoderSink extends _StringSinkConversionSink {
   final _Reviver _reviver;
   final Sink<Object> _sink;
 
-  _JsonDecoderSink(this._reviver, this._sink) : super(new StringBuffer());
+  _JsonDecoderSink(this._reviver, this._sink) : super(new StringBuffer(''));
 
   void close() {
     super.close();
     StringBuffer buffer = _stringSink;
     String accumulated = buffer.toString();
     buffer.clear();
     Object decoded = _parseJson(accumulated, _reviver);
     _sink.add(decoded);
     _sink.close();
   }
 }
 
 @patch
 class Utf8Decoder {
   @patch
-  Converter<List<int>, dynamic/*=T*/ > fuse/*<T>*/(
-      Converter<String, dynamic/*=T*/ > next) {
-    return super.fuse/*<T>*/(next);
+  Converter<List<int>, T> fuse<T>(Converter<String, T> next) {
+    return super.fuse(next);
   }
 
   // Currently not intercepting UTF8 decoding.
   @patch
   static String _convertIntercepted(
       bool allowMalformed, List<int> codeUnits, int start, int end) {
     return null; // This call was not intercepted.
   }
 }