Fix return-type for error-handlers in streams.

sdk/lib/async/stream_impl.dart

 // Copyright (c) 2012, 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.async;
 
 /** Abstract and private interface for a place to put events. */
 abstract class _EventSink<T> {
   void _add(T data);
   void _addError(Object error, StackTrace stackTrace);
@@ skipping 127 matching lines @@
 
   void onData(void handleData(T event)) {
     if (handleData == null) handleData = _nullDataHandler;
     // TODO(floitsch): the return type should be 'void', and the type
     // should be inferred.
     _onData = _zone.registerUnaryCallback/*<dynamic, T>*/(handleData);
   }
 
   void onError(Function handleError) {
     if (handleError == null) handleError = _nullErrorHandler;
-    _onError = _registerErrorHandler/*<T>*/(handleError, _zone);
+    _onError = _registerErrorHandler/*<dynamic/*void*/>*/(handleError, _zone);

[Lasse Reichstein Nielsen, 2016/05/09 15:43:03]

I need documentation for this comment. 

It's meaningful, so it should be treated as code, and it's not at all readable
(to me, at least).

[floitsch, 2016/05/09 16:53:55]

You mean, there is too much comment?
Do you prefer a comment stating that "dynamic" should be "void" ?

[Lasse Reichstein Nielsen, 2016/05/09 18:56:10]

I just don't know what it means.
I have learned that /*<dynamic>*/ is a temporary place-holder for <dynamic> and
it's really strong-mode *code*, not documentation, but is the /*void*/ inside it
meaningful too? Or is it only documentation? And if so, what does it mean (it's
not obvious)?

[floitsch, 2016/05/09 20:59:19]

The /*void*/ is just a comment. It means that I would like to put "void" here,
but can't and therefore use 'dynamic' instead.

Should I just remove the '/*void*/' ?

[Lasse Reichstein Nielsen, 2016/05/10 05:31:46]

I think so, yes. It's confusing to have a comment as part of another comment.
If you want to remind yourself that you want to write void (in case we make void
a first-class type), do that in a separate comment.

[floitsch, 2016/05/10 18:29:49]

Done.

   }
 
   void onDone(void handleDone()) {
     if (handleDone == null) handleDone = _nullDoneHandler;
     _onDone = _zone.registerCallback(handleDone);
   }
 
   void pause([Future resumeSignal]) {
     if (_isCanceled) return;
     bool wasPaused = _isPaused;
@@ skipping 928 matching lines @@
 class _EmptyStream<T> extends Stream<T> {
   const _EmptyStream() : super._internal();
   bool get isBroadcast => true;
   StreamSubscription<T> listen(void onData(T data),
                                {Function onError,
                                 void onDone(),
                                 bool cancelOnError}) {
     return new _DoneStreamSubscription<T>(onDone);
   }
 }