Update dart:async to match the Dart repo.

tool/input_sdk/lib/async/stream_transformers.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.async;
 
 /**
  * Wraps an [_EventSink] so it exposes only the [EventSink] interface.
  */
 class _EventSinkWrapper<T> implements EventSink<T> {
@@ skipping 10 matching lines @@
 /**
  * A StreamSubscription that pipes data through a sink.
  *
  * The constructor of this class takes a [_SinkMapper] which maps from
  * [EventSink] to [EventSink]. The input to the mapper is the output of
  * the transformation. The returned sink is the transformation's input.
  */
 class _SinkTransformerStreamSubscription<S, T>
     extends _BufferingStreamSubscription<T> {
   /// The transformer's input sink.
-  EventSink _transformerSink;
+  EventSink<S> _transformerSink;
 
   /// The subscription to the input stream.
   StreamSubscription<S> _subscription;
 
   _SinkTransformerStreamSubscription(Stream<S> source,
                                      _SinkMapper<S, T> mapper,
                                      void onData(T data),
                                      Function onError,
                                      void onDone(),
                                      bool cancelOnError)
@@ skipping 134 matching lines @@
 
   bool get isBroadcast => _stream.isBroadcast;
 
   _BoundSinkStream(this._stream, this._sinkMapper);
 
   StreamSubscription<T> listen(void onData(T event),
                                { Function onError,
                                  void onDone(),
                                  bool cancelOnError }) {
     cancelOnError = identical(true, cancelOnError);
-    StreamSubscription<T> subscription = new _SinkTransformerStreamSubscription(
-        _stream, _sinkMapper, onData, onError, onDone, cancelOnError);
+    StreamSubscription<T> subscription =
+        new _SinkTransformerStreamSubscription<S, T>(
+            _stream, _sinkMapper, onData, onError, onDone, cancelOnError);
     return subscription;
   }
 }
 
 /// Data-handler coming from [StreamTransformer.fromHandlers].
 typedef void _TransformDataHandler<S, T>(S data, EventSink<T> sink);
 /// Error-handler coming from [StreamTransformer.fromHandlers].
 typedef void _TransformErrorHandler<T>(
     Object error, StackTrace stackTrace, EventSink<T> sink);
 /// Done-handler coming from [StreamTransformer.fromHandlers].
 typedef void _TransformDoneHandler<T>(EventSink<T> sink);
 
 /**
  * Wraps handlers (from [StreamTransformer.fromHandlers]) into an `EventSink`.
  *
  * This way we can reuse the code from [_StreamSinkTransformer].
  */
 class _HandlerEventSink<S, T> implements EventSink<S> {
   final _TransformDataHandler<S, T> _handleData;
   final _TransformErrorHandler<T> _handleError;
   final _TransformDoneHandler<T> _handleDone;
 
   /// The output sink where the handlers should send their data into.
   final EventSink<T> _sink;
 
   _HandlerEventSink(this._handleData, this._handleError, this._handleDone,
                     this._sink);
 
-  void add(S data) => _handleData(data, _sink);
-  void addError(Object error, [StackTrace stackTrace])
-      => _handleError(error, stackTrace, _sink);
-  void close() => _handleDone(_sink);
+  void add(S data) { _handleData(data, _sink); }
+  void addError(Object error, [StackTrace stackTrace]) {
+    _handleError(error, stackTrace, _sink);
+  }
+  void close() { _handleDone(_sink); }
 }
 
 /**
  * A StreamTransformer that transformers events with the given handlers.
  *
  * Note that this transformer can only be used once.
  */
 class _StreamHandlerTransformer<S, T> extends _StreamSinkTransformer<S, T> {
 
   _StreamHandlerTransformer({
@@ skipping 13 matching lines @@
   }
 
   /** Default data handler forwards all data. */
   static void _defaultHandleData(var data, EventSink sink) {
     sink.add(data);
   }
 
   /** Default error handler forwards all errors. */
   static void _defaultHandleError(error, StackTrace stackTrace,
                                   EventSink sink) {
-    sink.addError(error);
+    sink.addError(error, stackTrace);
   }
 
   /** Default done handler forwards done. */
   static void _defaultHandleDone(EventSink sink) {
     sink.close();
   }
 }
 
 /// A closure mapping a stream and cancelOnError to a StreamSubscription.
 typedef StreamSubscription<T> _SubscriptionTransformer<S, T>(
@@ skipping 38 matching lines @@
                                  void onDone(),
                                  bool cancelOnError }) {
     cancelOnError = identical(true, cancelOnError);
     StreamSubscription<T> result = _transformer(_stream, cancelOnError);
     result.onData(onData);
     result.onError(onError);
     result.onDone(onDone);
     return result;
   }
 }