Steps towards making the convert library strong-mode compliant.

sdk/lib/convert/chunked_conversion.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;
 
 typedef void _ChunkedConversionCallback<T>(T accumulated);
 
 /**
+ * A converter that supports chunked conversions.
+ *
+ * In addition to immediate conversions from [S] to [T], a chunked converter
+ * also supports longer-running conversions from [S2] to [T2].
+ *
+ * Frequently, the source and target types are the same, but this is not a
+ * requirement. In particular, converters that work with lists in the
+ * immediate conversion, could flatten the type for the chunked conversion.
+ *
+ * For example, the [LineSplitter] class returns a `List<String>` for the
+ * immediate conversion, but returns individual `String`s in the chunked
+ * conversion.
+ */
+abstract class ChunkedConverter<S, T, S2, T2> extends Converter<S, T> {
+
+  const ChunkedConverter();
+
+  /**
+   * Starts a chunked conversion.
+   *
+   * The returned sink serves as input for the long-running conversion. The
+   * given [sink] serves as output.
+   */
+  ChunkedConversionSink<S2> startChunkedConversion(Sink<T2> sink) {
+    throw new UnsupportedError(
+        "This converter does not support chunked conversions: $this");
+  }
+
+  Stream<T2> bind(Stream<S2> stream) {
+    return new Stream<T2>.eventTransformed(
+        stream,
+        (EventSink<T2> sink) =>
+            new _ConverterStreamEventSink<S2, T2>(this, sink));
+  }
+
+  /**
+   * Fuses this instance with the given [other] converter.
+   *
+   * If [other] is a ChunkedConverter (with matching generic types), returns a
+   * [ChunkedConverter].
+   */
+  Converter<S, dynamic> fuse(Converter<T, dynamic> other) {
+    if (other is ChunkedConverter<T, dynamic, T2, dynamic>) {

[floitsch, 2016/04/11 18:37:53]

Looking at this again, I guess there is no way to make this strong-mode
compliant?
I would like to create the FusedChunkedConverter based on the dynamic type. The
only way I can see this working is using double-dispatch...

@Leaf: is there a way to do an 'is' check that doesn't look at the generic
types?
In that case I could write:
if (other is ChunkedConverter) {
  return other._fuseFromOther<S, T, S2, T2>(this);
}

_fuseFromOther<otherS, otherT, otherS2, otherT2>(ChunkedConverter<otherS,
otherT, otherS2, otherT2> other) {
  if (this is ChunkedConverter<otherT, T, otherT2, T2>) {
    return new _FusedChunkedConverter<otherS, T, otherS2, T2>(other, this);
  }
}

This would require users to extend the ChunkedConverter (instead of just
implementing the interface). Otherwise we could make that function public.

[Leaf, 2016/04/11 19:46:27]

I don't see anything in this code that is directly not strong-mode compliant
(but may be missing something).  Is the concern that this returns something
whose dynamic type is Converter<S, dynamic>, and that consequently strong mode
will not allow the result to be used as a Converter<S, SomethingConcrete>? 
That, I think is an issue.

I'm not sure quite what you mean by and 'is' check that doesn't look at the
generic types.  "other is ChunkedConverter" in some sense doesn't look at the
generic types, in that it will return true for any instantiation of
ChunkedConverter.  Strong mode generic classes are still covariant.  Is that not
what you want?

[floitsch, 2016/04/12 15:28:57]

My mistake. Somehow I was convinced that strong mode was invariant.

[Leaf, 2016/04/12 17:44:30]

We tried... but without generic methods it's hard to get off the ground without
covariance.  There probably is a long term strong mode/DDC issue here where
people will expect the result of fuse on two typed converters to be typed, but
it won't be (and casting it to a concrete Converter type will fail).

[floitsch, 2016/04/12 17:55:29]

Yes. This is not perfect yet...
I will make 'fuse' generic (in a future CL), but it won't help for the chunked
conversion case. Unless we add support for reading the generic types of
instances we will have to do a double-dispatch to get the full type. Not yet
sure what we want to do.

+      return new _FusedChunkedConverter<S, T, dynamic, S2, T2, dynamic>(
+          this, other);
+    }
+    return super.fuse(other);
+  }
+}
+
+/**
  * A [ChunkedConversionSink] is used to transmit data more efficiently between
  * two converters during chunked conversions.
  *
  * The basic `ChunkedConversionSink` is just a [Sink], and converters should
  * work with a plain `Sink`, but may work more efficiently with certain
  * specialized types of `ChunkedConversionSink`.
  *
  * It is recommended that implementations of `ChunkedConversionSink` extends
  * this class, to inherit any further methods that may be added to the class.
  */
@@ skipping 28 matching lines @@
   final _ChunkedConversionCallback<List<T>> _callback;
   final List<T> _accumulated = <T>[];
 
   _SimpleCallbackSink(this._callback);
 
   void add(T chunk) { _accumulated.add(chunk); }
   void close() { _callback(_accumulated); }
 }
 
 /**
- * This class converts implements the logic for a chunked conversion as a
+ * This class implements the logic for a chunked conversion as a
  * stream transformer.
  *
  * It is used as strategy in the [EventTransformStream].
  *
  * It also implements the [ChunkedConversionSink] interface so that it
  * can be used as output sink in a chunked conversion.
  */
 class _ConverterStreamEventSink<S, T> implements EventSink<S> {
   /** The output sink for the converter. */
   final EventSink<T> _eventSink;
 
   /**
    * The input sink for new data. All data that is received with
    * [handleData] is added into this sink.
    */
-  ChunkedConversionSink _chunkedSink;
+  ChunkedConversionSink<S> _chunkedSink;
 
-  _ConverterStreamEventSink(Converter converter, EventSink<T> sink)
+  _ConverterStreamEventSink(
+      ChunkedConverter<dynamic, dynamic, S, T> converter, EventSink<T> sink)

[floitsch, 2016/04/11 18:37:53]

This is the line that broke the build. Since not all converters have been
migrated yet external converters weren't implementing the ChunkedConverter
interface.

I had to revert to "Converter" here (as is on the left).
I could, for strong mode, make it a `Converter/*=ChunkedConverter<dynamic,
dynamic, S, T>*/ instead.

However, I just realized that the 'dynamic' would break in strong mode (even if
it's unused). I guess I will have to refactor this library again...

[Leaf, 2016/04/11 19:46:27]

I'm probably just off to a slow start this week, but not sure I see the issue
with dynamic here.  Can you elaborate?

[floitsch, 2016/04/12 15:28:57]

ditto.

       : this._eventSink = sink,
         _chunkedSink = converter.startChunkedConversion(sink);
 
   void add(S o) => _chunkedSink.add(o);
   void addError(Object error, [StackTrace stackTrace]) {
     _eventSink.addError(error, stackTrace);
   }
   void close() => _chunkedSink.close();
 }
+
+/**
+ * Fuses two chunked converters.
+ */
+class _FusedChunkedConverter<S, M, T, S2, M2, T2> extends
+    ChunkedConverter<S, T, S2, T2> {
+  final ChunkedConverter<S, M, S2, M2> _first;
+  final ChunkedConverter<M, T, M2, T2> _second;
+
+  _FusedChunkedConverter(this._first, this._second);
+
+  T convert(S input) => _second.convert(_first.convert(input));
+
+  ChunkedConversionSink<S2> startChunkedConversion(Sink<T2> sink) {
+    return _first.startChunkedConversion(_second.startChunkedConversion(sink));
+  }
+}