Make dart:convert strong mode clean.

sdk/lib/convert/json.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.
 
 part of dart.convert;
 
 /**
  * Error thrown by JSON serialization if an object cannot be serialized.
  *
  * The [unsupportedObject] field holds that object that failed to be serialized.
@@ skipping 121 matching lines @@
    * Converts [value] to a JSON string.
    *
    * If value contains objects that are not directly encodable to a JSON
    * string (a value that is not a number, boolean, string, null, list or a map
    * with string keys), the [toEncodable] function is used to convert it to an
    * object that must be directly encodable.
    *
    * If [toEncodable] is omitted, it defaults to a function that returns the
    * result of calling `.toJson()` on the unencodable object.
    */
-  String encode(Object value, {toEncodable(var object)}) {
+  String encode(Object value, {dynamic toEncodable(dynamic object)}) {

[Lasse Reichstein Nielsen, 2016/05/11 09:06:14]

Can you just remove the "dynamic" here?
Or does that mean something else in strong mode?

[floitsch, 2016/05/11 11:20:44]

I had to add it. I'm not really sure which one is better, but I feel like
dynamic->dynamic is what this function does, and as such, that should be its
type.

[floitsch, 2016/05/11 14:14:54]

As discussed in person: removed them again.

     if (toEncodable == null) toEncodable = _toEncodable;
     if (toEncodable == null) return encoder.convert(value);
     return new JsonEncoder(toEncodable).convert(value);
   }
 
   JsonEncoder get encoder {
     if (_toEncodable == null) return const JsonEncoder();
     return new JsonEncoder(_toEncodable);
   }
 
   JsonDecoder get decoder {
     if (_reviver == null) return const JsonDecoder();
     return new JsonDecoder(_reviver);
   }
 }
 
 /**
  * This class converts JSON objects to strings.
  */
-class JsonEncoder extends ChunkedConverter<Object, String, Object, String> {
+class JsonEncoder extends Converter<Object, String> {
   /**
    * The string used for indention.
    *
    * When generating multi-line output, this string is inserted once at the
    * beginning of each indented line for each level of indentation.
    *
    * If `null`, the output is encoded as a single line.
    */
   final String indent;
 
   /**
    * Function called on non-encodable objects to return a replacement
    * encodable object that will be encoded in the orignal's place.
    */
-  final Function _toEncodable;
+  final _ToEncodable _toEncodable;
 
   /**
    * Creates a JSON encoder.
    *
    * The JSON encoder handles numbers, strings, booleans, null, lists and
    * maps directly.
    *
    * Any other object is attempted converted by [toEncodable] to an
    * object that is of one of the convertible types.
    *
    * If [toEncodable] is omitted, it defaults to calling `.toJson()` on
    * the object.
    */
-  const JsonEncoder([Object toEncodable(Object nonSerializable)])
+  const JsonEncoder([dynamic toEncodable(dynamic nonSerializable)])
       : this.indent = null,
         this._toEncodable = toEncodable;
 
   /**
    * Creates a JSON encoder that creates multi-line JSON.
    *
    * The encoding of elements of lists and maps are indented and put on separate
    * lines. The [indent] string is prepended to these elements, once for each
    * level of indentation.
    *
    * If [indent] is `null`, the output is encoded as a single line.
    *
    * The JSON encoder handles numbers, strings, booleans, null, lists and
    * maps directly.
    *
    * Any other object is attempted converted by [toEncodable] to an
    * object that is of one of the convertible types.
    *
    * If [toEncodable] is omitted, it defaults to calling `.toJson()` on
    * the object.
    */
   const JsonEncoder.withIndent(this.indent,
-      [Object toEncodable(Object nonSerializable)])
+      [dynamic toEncodable(dynamic nonSerializable)])

[Lasse Reichstein Nielsen, 2016/05/11 09:06:14]

Is this necessary?
Is it because an int->int function isn't a subtype of Object->Object?

[floitsch, 2016/05/11 11:20:45]

Unfortunately necessary. Example output of the analyzer:

[warning] Unsound implicit cast from (dynamic) → dynamic to (Object) → Object
(convert/json.dart, line 145, col 28)

       : this._toEncodable = toEncodable;
 
   /**
    * Converts [object] to a JSON [String].
    *
    * Directly serializable values are [num], [String], [bool], and [Null], as
    * well as some [List] and [Map] values. For [List], the elements must all be
    * serializable. For [Map], the keys must be [String] and the values must be
    * serializable.
    *
@@ skipping 36 matching lines @@
       return new _JsonUtf8EncoderSink(sink._sink, _toEncodable,
                                       JsonUtf8Encoder._utf8Encode(indent),
                                       JsonUtf8Encoder.DEFAULT_BUFFER_SIZE);
     }
     return new _JsonEncoderSink(sink, _toEncodable, indent);
   }
 
   // Override the base class's bind, to provide a better type.
   Stream<String> bind(Stream<Object> stream) => super.bind(stream);
 
-  Converter<Object, dynamic> fuse(Converter<String, dynamic> other) {
+  Converter<Object, dynamic/*=T*/> fuse/*<T>*/(
+      Converter<String, dynamic/*=T*/> other) {
     if (other is Utf8Encoder) {
-      return new JsonUtf8Encoder(indent, _toEncodable);
+      return new JsonUtf8Encoder(indent, _toEncodable)
+          as dynamic/*=Converter<Object, T>*/;
     }
-    return super.fuse(other);
+    return super.fuse/*<T>*/(other);
   }
 }
 
 /**
  * Encoder that encodes a single object as a UTF-8 encoded JSON string.
  *
  * This encoder works equivalently to first converting the object to
  * a JSON string, and then UTF-8 encoding the string, but without
  * creating an intermediate string.
  */
-class JsonUtf8Encoder extends
-    ChunkedConverter<Object, List<int>, Object, List<int>> {
+class JsonUtf8Encoder extends Converter<Object, List<int>> {
   /** Default buffer size used by the JSON-to-UTF-8 encoder. */
   static const int DEFAULT_BUFFER_SIZE = 256;
   /** Indentation used in pretty-print mode, `null` if not pretty. */
   final List<int> _indent;
   /** Function called with each un-encodable object encountered. */
-  final Function _toEncodable;
+  final _ToEncodable _toEncodable;
   /** UTF-8 buffer size. */
   final int _bufferSize;
 
   /**
    * Create converter.
    *
    * If [indent] is non-`null`, the converter attempts to "pretty-print" the
    * JSON, and uses `indent` as the indentation. Otherwise the result has no
    * whitespace outside of string literals.
    * If `indent` contains characters that are not valid JSON whitespace
    * characters, the result will not be valid JSON. JSON whitespace characters
    * are space (U+0020), tab (U+0009), line feed (U+000a) and carriage return
    * (U+000d) ([ECMA
    * 404](http://www.ecma-international.org/publications/standards/Ecma-404.htm)).
    *
    * The [bufferSize] is the size of the internal buffers used to collect
    * UTF-8 code units.
    * If using [startChunkedConversion], it will be the size of the chunks.
    *
    * The JSON encoder handles numbers, strings, booleans, null, lists and maps
    * directly.
    *
    * Any other object is attempted converted by [toEncodable] to an object that
    * is of one of the convertible types.
    *
    * If [toEncodable] is omitted, it defaults to calling `.toJson()` on the
    * object.
    */
   JsonUtf8Encoder([String indent,
-                   toEncodable(Object object),
+                   dynamic toEncodable(dynamic object),
                    int bufferSize = DEFAULT_BUFFER_SIZE])
       : _indent = _utf8Encode(indent),
         _toEncodable = toEncodable,
         _bufferSize = bufferSize;
 
   static List<int> _utf8Encode(String string) {
     if (string == null) return null;
     if (string.isEmpty) return new Uint8List(0);
     checkAscii: {
       for (int i = 0; i < string.length; i++) {
@@ skipping 54 matching lines @@
       byteSink = new ByteConversionSink.from(sink);
     }
     return new _JsonUtf8EncoderSink(byteSink, _toEncodable,
                                     _indent, _bufferSize);
   }
 
   // Override the base class's bind, to provide a better type.
   Stream<List<int>> bind(Stream<Object> stream) {
     return super.bind(stream);
   }
-
-  Converter<Object, dynamic> fuse(Converter<List<int>, dynamic> other) {
-    return super.fuse(other);
-  }
 }
 
 /**
  * Implements the chunked conversion from object to its JSON representation.
  *
  * The sink only accepts one value, but will produce output in a chunked way.
  */
 class _JsonEncoderSink extends ChunkedConversionSink<Object> {
   final String _indent;
-  final Function _toEncodable;
+  final _ToEncodable _toEncodable;
   final StringConversionSink _sink;
   bool _isDone = false;
 
   _JsonEncoderSink(this._sink, this._toEncodable, this._indent);
 
   /**
    * Encodes the given object [o].
    *
    * It is an error to invoke this method more than once on any instance. While
    * this makes the input effectly non-chunked the output will be generated in
@@ skipping 12 matching lines @@
   void close() { /* do nothing */ }
 }
 
 /**
  * Sink returned when starting a chunked conversion from object to bytes.
  */
 class _JsonUtf8EncoderSink extends ChunkedConversionSink<Object> {
   /** The byte sink receiveing the encoded chunks. */
   final ByteConversionSink _sink;
   final List<int> _indent;
-  final Function _toEncodable;
+  final _ToEncodable _toEncodable;
   final int _bufferSize;
   bool _isDone = false;
   _JsonUtf8EncoderSink(this._sink, this._toEncodable, this._indent,
                        this._bufferSize);
 
   /** Callback called for each slice of result bytes. */
   void _addChunk(Uint8List chunk, int start, int end) {
     _sink.addSlice(chunk, start, end, false);
   }
 
@@ skipping 12 matching lines @@
     if (!_isDone) {
       _isDone = true;
       _sink.close();
     }
   }
 }
 
 /**
  * This class parses JSON strings and builds the corresponding objects.
  */
-class JsonDecoder extends ChunkedConverter<String, Object, String, Object> {
+class JsonDecoder extends Converter<String, Object> {
   final _Reviver _reviver;
   /**
    * Constructs a new JsonDecoder.
    *
    * The [reviver] may be `null`.
    */
   const JsonDecoder([reviver(var key, var value)]) : this._reviver = reviver;
 
   /**
    * Converts the given JSON-string [input] to its corresponding object.
@@ skipping 22 matching lines @@
   // Override the base class's bind, to provide a better type.
   Stream<Object> bind(Stream<String> stream) => super.bind(stream);
 }
 
 // Internal optimized JSON parsing implementation.
 external _parseJson(String source, reviver(key, value));
 
 
 // Implementation of encoder/stringifier.
 
-Object _defaultToEncodable(object) => object.toJson();
+dynamic _defaultToEncodable(dynamic object) => object.toJson();
 
 /**
  * JSON encoder that traverses an object structure and writes JSON source.
  *
  * This is an abstract implementation that doesn't decide on the output
  * format, but writes the JSON through abstract methods like [writeString].
  */
 abstract class _JsonStringifier {
   // Character code constants.
   static const int BACKSPACE       = 0x08;
   static const int TAB             = 0x09;
   static const int NEWLINE         = 0x0a;
   static const int CARRIAGE_RETURN = 0x0d;
   static const int FORM_FEED       = 0x0c;
   static const int QUOTE           = 0x22;
   static const int CHAR_0          = 0x30;
   static const int BACKSLASH       = 0x5c;
   static const int CHAR_b          = 0x62;
   static const int CHAR_f          = 0x66;
   static const int CHAR_n          = 0x6e;
   static const int CHAR_r          = 0x72;
   static const int CHAR_t          = 0x74;
   static const int CHAR_u          = 0x75;
 
   /** List of objects currently being traversed. Used to detect cycles. */
   final List _seen = new List();
   /** Function called for each un-encodable object encountered. */
-  final Function _toEncodable;
+  final _ToEncodable _toEncodable;
 
-  _JsonStringifier(Object _toEncodable(Object o))
-      : _toEncodable = (_toEncodable != null) ? _toEncodable
-                                              : _defaultToEncodable;
+  _JsonStringifier(dynamic toEncodable(dynamic o))
+      : _toEncodable = toEncodable ?? _defaultToEncodable;
 
   /** Append a string to the JSON output. */
   void writeString(String characters);
   /** Append part of a string to the JSON output. */
   void writeStringSlice(String characters, int start, int end);
   /** Append a single character, given by its code point, to the JSON output. */
   void writeCharCode(int charCode);
   /** Write a number to the JSON output. */
   void writeNumber(num number);
 
@@ skipping 149 matching lines @@
       writeObject(list[0]);
       for (int i = 1; i < list.length; i++) {
         writeString(',');
         writeObject(list[i]);
       }
     }
     writeString(']');
   }
 
   /** Serialize a [Map]. */
-  bool writeMap(Map<String, Object> map) {
+  bool writeMap(Map map) {
     if (map.isEmpty) {
       writeString("{}");
       return true;
     }
     List keyValueList = new List(map.length * 2);
     int i = 0;
     bool allStringKeys = true;
     map.forEach((key, value) {
       if (key is! String) {
         allStringKeys = false;
@@ skipping 21 matching lines @@
  * [Map] objects using the specified indent value.
  *
  * Subclasses should implement [writeIndentation].
  */
 abstract class _JsonPrettyPrintMixin implements _JsonStringifier {
   int _indentLevel = 0;
 
   /**
    * Add [indentLevel] indentations to the JSON output.
    */
-  void writeIndentation(indentLevel);
+  void writeIndentation(int indentLevel);
 
   void writeList(List list) {
     if (list.isEmpty) {
       writeString('[]');
     } else {
       writeString('[\n');
       _indentLevel++;
       writeIndentation(_indentLevel);
       writeObject(list[0]);
       for (int i = 1; i < list.length; i++) {
@@ skipping 56 matching lines @@
    * Convert object to a string.
    *
    * The [toEncodable] function is used to convert non-encodable objects
    * to encodable ones.
    *
    * If [indent] is not `null`, the resulting JSON will be "pretty-printed"
    * with newlines and indentation. The `indent` string is added as indentation
    * for each indentation level. It should only contain valid JSON whitespace
    * characters (space, tab, carriage return or line feed).
    */
-  static String stringify(object, toEncodable(object), String indent) {
+  static String stringify(
+      object, dynamic toEncodable(dynamic o), String indent) {
     StringBuffer output = new StringBuffer();
     printOn(object, output, toEncodable, indent);
     return output.toString();
   }
 
   /**
    * Convert object to a string, and write the result to the [output] sink.
    *
    * The result is written piecemally to the sink.
    */
-  static void printOn(object, StringSink output, toEncodable(object),
+  static void printOn(object, StringSink output, dynamic toEncodable(dynamic o),
                       String indent) {
     var stringifier;
     if (indent == null) {
       stringifier = new _JsonStringStringifier(output, toEncodable);
     } else {
       stringifier =
           new _JsonStringStringifierPretty(output, toEncodable, indent);
     }
     stringifier.writeObject(object);
   }
 
   void writeNumber(num number) {
     _sink.write(number.toString());
   }
   void writeString(String string) {
     _sink.write(string);
   }
   void writeStringSlice(String string, int start, int end) {
     _sink.write(string.substring(start, end));
   }
   void writeCharCode(int charCode) {
     _sink.writeCharCode(charCode);
   }
 }
 
 class _JsonStringStringifierPretty extends _JsonStringStringifier
                                    with _JsonPrettyPrintMixin {
   final String _indent;
 
-  _JsonStringStringifierPretty(StringSink sink, Function toEncodable,
+  _JsonStringStringifierPretty(StringSink sink, dynamic toEncodable(dynamic o),
                                this._indent)
       : super(sink, toEncodable);
 
   void writeIndentation(int count) {
     for (int i = 0; i < count; i++) writeString(_indent);
   }
 }
 
+typedef void _AddChunk(Uint8List list, int start, int end);
+
 /**
  * Specialization of [_JsonStringifier] that writes the JSON as UTF-8.
  *
  * The JSON text is UTF-8 encoded and written to [Uint8List] buffers.
  * The buffers are then passed back to a user provided callback method.
  */
 class _JsonUtf8Stringifier extends _JsonStringifier {
   final int bufferSize;
-  final Function addChunk;
+  final _AddChunk addChunk;
   Uint8List buffer;
   int index = 0;
 
-  _JsonUtf8Stringifier(toEncodable, int bufferSize, this.addChunk)
+  _JsonUtf8Stringifier(
+      dynamic toEncodable(dynamic o), int bufferSize, this.addChunk)
       : this.bufferSize = bufferSize,
         buffer = new Uint8List(bufferSize),
         super(toEncodable);
 
   /**
    * Convert [object] to UTF-8 encoded JSON.
    *
    * Calls [addChunk] with slices of UTF-8 code units.
    * These will typically have size [bufferSize], but may be shorter.
    * The buffers are not reused, so the [addChunk] call may keep and reuse the
    * chunks.
    *
    * If [indent] is non-`null`, the result will be "pretty-printed" with extra
    * newlines and indentation, using [indent] as the indentation.
    */
   static void stringify(Object object,
                         List<int> indent,
-                        toEncodableFunction(Object o),
+                        dynamic toEncodable(dynamic o),
                         int bufferSize,
                         void addChunk(Uint8List chunk, int start, int end)) {
     _JsonUtf8Stringifier stringifier;
     if (indent != null) {
-      stringifier = new _JsonUtf8StringifierPretty(toEncodableFunction, indent,
+      stringifier = new _JsonUtf8StringifierPretty(toEncodable, indent,
                                                    bufferSize, addChunk);
     } else {
-      stringifier = new _JsonUtf8Stringifier(toEncodableFunction,
-                                             bufferSize, addChunk);
+      stringifier = new _JsonUtf8Stringifier(toEncodable, bufferSize, addChunk);
     }
     stringifier.writeObject(object);
     stringifier.flush();
   }
 
   /**
    * Must be called at the end to push the last chunk to the [addChunk]
    * callback.
    */
   void flush() {
@@ skipping 89 matching lines @@
     buffer[index++] = byte;
   }
 }
 
 /**
  * Pretty-printing version of [_JsonUtf8Stringifier].
  */
 class _JsonUtf8StringifierPretty extends _JsonUtf8Stringifier
                                  with _JsonPrettyPrintMixin {
   final List<int> indent;
-  _JsonUtf8StringifierPretty(toEncodableFunction, this.indent,
-                             bufferSize, addChunk)
+  _JsonUtf8StringifierPretty(
+      dynamic toEncodableFunction(dynamic o), this.indent,
+      bufferSize, void addChunk(Uint8List buffer, int start, int end))
       : super(toEncodableFunction, bufferSize, addChunk);
 
   void writeIndentation(int count) {
     List<int> indent = this.indent;
     int indentLength = indent.length;
     if (indentLength == 1) {
       int char = indent[0];
       while (count > 0) {
         writeByte(char);
         count -= 1;
       }
       return;
     }
     while (count > 0) {
       count--;
       int end = index + indentLength;
       if (end <= buffer.length) {
         buffer.setRange(index, end, indent);
         index = end;
       } else {
         for (int i = 0; i < indentLength; i++) {
           writeByte(indent[i]);
         }
       }
     }
   }
 }