Use typedefs in lib.

sdk/lib/async/stream_pipe.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;
 
 /**
  * Utility function to attach a stack trace to an [error]  if it doesn't have
  * one already.
  */
@@ skipping 122 matching lines @@
   void _onCancel() {
     if (_subscription != null) {
       StreamSubscription subscription = _subscription;
       _subscription = null;
       subscription.cancel();
     }
   }
 
   // Methods used as listener on source subscription.
 
-  // TODO(ahe): Restore type when feature is implemented in dart2js
-  // checked mode. http://dartbug.com/7733
-  void _handleData(/*S*/ data) {
+  void _handleData(S data) {
     _stream._handleData(data, this);
   }
 
   void _handleError(error) {
     _stream._handleError(error, this);
   }
 
   void _handleDone() {
     _stream._handleDone(this);
   }
@@ skipping 268 matching lines @@
  * A [StreamTransformer] that modifies stream events.
  *
  * This class is used by [StreamTransformer]'s factory constructor.
  * It is actually an [StreamEventTransformer] where the functions used to
  * modify the events are passed as constructor arguments.
  *
  * If an argument is omitted, it acts as the default method from
  * [StreamEventTransformer].
  */
 class _StreamTransformerImpl<S, T> extends StreamEventTransformer<S, T> {
-  // TODO(ahe): Restore type when feature is implemented in dart2js
-  // checked mode. http://dartbug.com/7733
-  final Function /*_TransformDataHandler<S, T>*/ _handleData;
+  final _TransformDataHandler<S, T> _handleData;
   final _TransformErrorHandler<T> _handleError;
   final _TransformDoneHandler<T> _handleDone;
 
   _StreamTransformerImpl(void handleData(S data, EventSink<T> sink),
                          void handleError(data, EventSink<T> sink),
                          void handleDone(EventSink<T> sink))
       : this._handleData  = (handleData == null  ? _defaultHandleData
                                                  : handleData),
         this._handleError = (handleError == null ? _defaultHandleError
                                                  : handleError),
         this._handleDone  = (handleDone == null  ? _defaultHandleDone
                                                  : handleDone);
 
   void handleData(S data, EventSink<T> sink) {
     _handleData(data, sink);
   }
 
   void handleError(error, EventSink<T> sink) {
     _handleError(error, sink);
   }
 
   void handleDone(EventSink<T> sink) {
     _handleDone(sink);
   }
 }