Fix most strong mode warnings.

lib/src/subscription_stream.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';
 
 import "delegate/stream_subscription.dart";
 
 /// A [Stream] adapter for a [StreamSubscription].
 ///
 /// This class allows a `StreamSubscription` to be treated as a `Stream`.
 ///
 /// The subscription is paused until the stream is listened to,
 /// then it is resumed and the events are passed on to the
 /// stream's new subscription.
 ///
 /// This class assumes that is has control over the original subscription.
 /// If other code is accessing the subscription, results may be unpredictable.
 class SubscriptionStream<T> extends Stream<T> {
   /// The subscription providing the events for this stream.
-  StreamSubscription _source;
+  StreamSubscription<T> _source;
 
   /// Create a single-subscription `Stream` from [subscription].
   ///
   /// The `subscription` should not be paused. This class will not resume prior
   /// pauses, so being paused is indistinguishable from not providing any
   /// events.
   ///
   /// If the `subscription` doesn't send any `done` events, neither will this
   /// stream. That may be an issue if `subscription` was made to cancel on
   /// an error.
-  SubscriptionStream(StreamSubscription subscription)
+  SubscriptionStream(StreamSubscription<T> subscription)
        : _source = subscription {
     _source.pause();
     // Clear callbacks to avoid keeping them alive unnecessarily.
     _source.onData(null);
     _source.onError(null);
     _source.onDone(null);
   }
 
   StreamSubscription<T> listen(void onData(T event),
                                {Function onError,
                                 void onDone(),
                                 bool cancelOnError}) {
     if (_source == null) {
       throw new StateError("Stream has already been listened to.");
     }
     cancelOnError = (true == cancelOnError);
     var subscription = _source;
     _source = null;
-    var result;
-    if (cancelOnError) {
-      result = new _CancelOnErrorSubscriptionWrapper<T>(subscription);
-    } else {
-      // Wrap the subscription to ensure correct type parameter.
-      result = new DelegatingStreamSubscription<T>(subscription);
-    }
+    var result = cancelOnError
+        ? new _CancelOnErrorSubscriptionWrapper<T>(subscription)
+        // Wrap the subscription to ensure correct type parameter.

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

Definite no to having comments inside conditional expressions.
Keep the if-statement, even if you have to type the variable.
(Or maybe we should change strong mode so it can infer types from the initial
assignments to a variable, even if they are not as an initializer expression).

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

I'm actually just going to remove the wrapping, since the original parameter is
type-annotated anyway.

+        : new DelegatingStreamSubscription<T>(subscription);
     result.onData(onData);
     result.onError(onError);
     result.onDone(onDone);
     subscription.resume();
     return result;
   }
 }
 
 /// Subscription wrapper that cancels on error.
 ///
@@ skipping 22 matching lines @@
       } else {
         if (handleError is ZoneBinaryCallback) {
           handleError(error, stackTrace);
         } else {
           handleError(error);
         }
       }
     });
   }
 }