Fix most strong mode warnings.

lib/src/stream_completer.dart

 // Copyright (c) 2015, 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.
 
 import "dart:async";
 
 /// A single-subscription [stream] where the contents are provided later.
 ///
 /// It is generally recommended that you never create a `Future<Stream>`
 /// because you can just directly create a stream that doesn't do anything
 /// until it's ready to do so.
 /// This class can be used to create such a stream.
 ///
 /// The [stream] is a normal stream that you can listen to immediately,
 /// but until either [setSourceStream] or [setEmpty] is called,
 /// the stream won't produce any events.
 ///
 /// The same effect can be achieved by using a [StreamController]
 /// and adding the stream using `addStream` when both
 /// the controller's stream is listened to and the source stream is ready.
 /// This class attempts to shortcut some of the overhead when possible.
 /// For example, if the [stream] is only listened to
 /// after the source stream has been set,
 /// the listen is performed directly on the source stream.
 class StreamCompleter<T> {
   /// The stream doing the actual work, is returned by [stream].
-  final _CompleterStream _stream = new _CompleterStream<T>();
+  final _stream = new _CompleterStream<T>();
 
   /// Convert a `Future<Stream>` to a `Stream`.
   ///
   /// This creates a stream using a stream completer,
   /// and sets the source stream to the result of the future when the
   /// future completes.
   ///
   /// If the future completes with an error, the returned stream will
   /// instead contain just that error.
-  static Stream fromFuture(Future<Stream> streamFuture) {
-    var completer = new StreamCompleter();
+  static Stream/*<T>*/ fromFuture/*<T>*/(Future<Stream/*<T>*/> streamFuture) {
+    var completer = new StreamCompleter/*<T>*/();
     streamFuture.then(completer.setSourceStream,
         onError: completer.setError);
     return completer.stream;
   }
 
   /// The stream of this completer.
   ///
   /// This stream is always a single-subscription stream.
   ///
   /// When a source stream is provided, its events will be forwarded to
@@ skipping 53 matching lines @@
     setSourceStream(new Stream.fromFuture(new Future.error(error, stackTrace)));
   }
 }
 
 /// Stream completed by [StreamCompleter].
 class _CompleterStream<T> extends Stream<T> {
   /// Controller for an intermediate stream.
   ///
   /// Created if the user listens on this stream before the source stream
   /// is set, or if using [_setEmpty] so there is no source stream.
-  StreamController _controller;
+  StreamController<T> _controller;
 
   /// Source stream for the events provided by this stream.
   ///
   /// Set when the completer sets the source stream using [_setSourceStream]
   /// or [_setEmpty].
-  Stream _sourceStream;
+  Stream<T> _sourceStream;
 
   StreamSubscription<T> listen(onData(T data),
                                {Function onError,
                                 void onDone(),
                                 bool cancelOnError}) {
     if (_controller == null) {
       if (_sourceStream != null && !_sourceStream.isBroadcast) {
         // If the source stream is itself single subscription,
         // just listen to it directly instead of creating a controller.
         return _sourceStream.listen(onData, onError: onError, onDone: onDone,
@@ skipping 48 matching lines @@
     _sourceStream = _controller.stream;  // Mark stream as set.
     _controller.close();
   }
 
   // Creates the [_controller].
   void _createController() {
     assert(_controller == null);
     _controller = new StreamController<T>(sync: true);
   }
 }