Fix most strong mode warnings.

lib/src/stream_group.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 collection of streams whose events are unified and sent through a central
 /// stream.
 ///
 /// Both errors and data events are forwarded through [stream]. The streams in
 /// the group won't be listened to until [stream] has a listener. **Note that
 /// this means that events emitted by broadcast streams will be dropped until
 /// [stream] has a listener.**
 ///
 /// If the `StreamGroup` is constructed using [new StreamGroup], [stream] will be

[Lasse Reichstein Nielsen, 2016/03/29 21:53:59]

While-you-are-here: long line.

[nweiz, 2016/03/30 00:57:19]

Done.

 /// single-subscription. In this case, if [stream] is paused or canceled, all
 /// streams in the group will likewise be paused or canceled, respectively.
 ///
 /// If the `StreamGroup` is constructed using [new StreamGroup.broadcast],
 /// [stream] will be a broadcast stream. In this case, the streams in the group
 /// will never be paused and single-subscription streams in the group will never
 /// be canceled. **Note that single-subscription streams in a broadcast group
 /// may drop events if a listener is added and later removed.** Broadcast
 /// streams in the group will be canceled once [stream] has no listeners, and
 /// will be listened to again once [stream] has listeners.
@@ skipping 20 matching lines @@
   /// If it's a broadcast group and it goes dormant again, broadcast stream
   /// subscriptions will be canceled and set to null again. Single-subscriber
   /// stream subscriptions will be left intact, since they can't be
   /// re-subscribed.
   final _subscriptions = new Map<Stream<T>, StreamSubscription<T>>();
 
   /// Merges the events from [streams] into a single (single-subscriber) stream.
   ///
   /// This is equivalent to adding [streams] to a group, closing that group, and
   /// returning its stream.
-  static Stream merge(Iterable<Stream> streams) {
-    var group = new StreamGroup();
+  static Stream/*<T>*/ merge/*<T>*/(Iterable<Stream/*<T>*/> streams) {
+    var group = new StreamGroup/*<T>*/();
     streams.forEach(group.add);
     group.close();
     return group.stream;
   }
 
   /// Creates a new stream group where [stream] is single-subscriber.
   StreamGroup() {
     _controller = new StreamController<T>(
         onListen: _onListen,
         onPause: _onPause,
@@ skipping 117 matching lines @@
       // it has no listeners.
       if (!stream.isBroadcast) return;
       subscription.cancel();
       _subscriptions[stream] = null;
     });
   }
 
   /// Starts actively forwarding events from [stream] to [_controller].
   ///
   /// This will pause the resulting subscription if [this] is paused.
-  StreamSubscription _listenToStream(Stream stream) {
+  StreamSubscription<T> _listenToStream(Stream<T> stream) {
     var subscription = stream.listen(
         _controller.add,
         onError: _controller.addError,
         onDone: () => remove(stream));
     if (_state == _StreamGroupState.paused) subscription.pause();
     return subscription;
   }
 
   /// Closes the group, indicating that no more streams will be added.
   ///
@@ skipping 42 matching lines @@
 
   /// The name of the state.
   ///
   /// Used for debugging.
   final String name;
 
   const _StreamGroupState(this.name);
 
   String toString() => name;
 }