Make pub strong-mode clean.

lib/src/error_group.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.
 
 import 'dart:async';
 
 /// An [ErrorGroup] entangles the errors of multiple [Future]s and [Stream]s
 /// with one another.
 ///
 /// This allows APIs to expose multiple [Future]s and [Stream]s that have
@@ skipping 47 matching lines @@
   ErrorGroup() {
     this._done = new _ErrorGroupFuture(this, _doneCompleter.future);
   }
 
   /// Registers a [Future] as a member of [this].
   ///
   /// Returns a wrapped version of [future] that should be used in its place.
   ///
   /// If all members of [this] have already completed successfully or with an
   /// error, it's a [StateError] to try to register a new [Future].
-  Future registerFuture(Future future) {
+  Future/*<T>*/ registerFuture/*<T>*/(Future/*<T>*/ future) {
     if (_isDone) {
       throw new StateError("Can't register new members on a complete "
           "ErrorGroup.");
     }
 
     var wrapped = new _ErrorGroupFuture(this, future);
     _futures.add(wrapped);
     return wrapped;
   }
 
   /// Registers a [Stream] as a member of [this].
   ///
   /// Returns a wrapped version of [stream] that should be used in its place.
   /// The returned [Stream] will be multi-subscription if and only if [stream]
   /// is.
   ///
   /// Since all errors in a group are passed to all members, the returned
   /// [Stream] will automatically unsubscribe all its listeners when it
   /// encounters an error.
   ///
   /// If all members of [this] have already completed successfully or with an
   /// error, it's a [StateError] to try to register a new [Stream].
-  Stream registerStream(Stream stream) {
+  Stream/*<T>*/ registerStream/*<T>*/(Stream/*<T>*/ stream) {
     if (_isDone) {
       throw new StateError("Can't register new members on a complete "
           "ErrorGroup.");
     }
 
     var wrapped = new _ErrorGroupStream(this, stream);
     _streams.add(wrapped);
     return wrapped;
   }
 
@@ skipping 52 matching lines @@
         _streams.every((stream) => stream._isDone);
     if (_isDone) _doneCompleter.complete();
   }
 }
 
 /// A [Future] wrapper that keeps track of whether it's been completed and
 /// whether it has any listeners.
 ///
 /// It also notifies its parent [ErrorGroup] when it completes successfully or
 /// receives an error.
-class _ErrorGroupFuture implements Future {
+class _ErrorGroupFuture<T> implements Future<T> {
   /// The parent [ErrorGroup].
   final ErrorGroup _group;
 
   /// Whether [this] has completed, either successfully or with an error.
   var _isDone = false;
 
   /// The underlying [Completer] for [this].
-  final _completer = new Completer();
+  final _completer = new Completer<T>();
 
   /// Whether [this] has any listeners.
   bool _hasListeners = false;
 
   /// Creates a new [_ErrorGroupFuture] that's a child of [_group] and wraps
   /// [inner].
-  _ErrorGroupFuture(this._group, Future inner) {
+  _ErrorGroupFuture(this._group, Future<T> inner) {
     inner.then((value) {
       if (!_isDone) _completer.complete(value);
       _isDone = true;
       _group._signalFutureComplete(this);
     }).catchError(_group._signalError);
 
     // Make sure _completer.future doesn't automatically send errors to the
     // top-level.
     _completer.future.catchError((_) {});
   }
 
-  Future then(onValue(value), {Function onError}) {
+  Future/*<S>*/ then/*<S>*/(/*=S*/ onValue(/*=T*/ value), {Function onError}) {
     _hasListeners = true;
     return _completer.future.then(onValue, onError: onError);
   }
 
-  Future catchError(Function onError, {bool test(Object error)}) {
+  Future<T> catchError(Function onError, {bool test(Object error)}) {
     _hasListeners = true;
     return _completer.future.catchError(onError, test: test);
   }
 
-  Future whenComplete(void action()) {
+  Future<T> whenComplete(void action()) {
     _hasListeners = true;
     return _completer.future.whenComplete(action);
   }
 
-  Future timeout(Duration timeLimit, {void onTimeout()}) {
+  Future<T> timeout(Duration timeLimit, {onTimeout()}) {
     _hasListeners = true;
     return _completer.future.timeout(timeLimit, onTimeout: onTimeout);
   }
 
-  Stream asStream() {
+  Stream<T> asStream() {
     _hasListeners = true;
     return _completer.future.asStream();
   }
 
   /// Signal that an error from [_group] should be propagated through [this],
   /// unless it's already complete.
   void _signalError(var error, [StackTrace stackTrace]) {
     if (!_isDone) _completer.completeError(error, stackTrace);
     _isDone = true;
   }
 }
 
 // TODO(nweiz): currently streams never top-level unhandled errors (issue 7843).
 // When this is fixed, this class will need to prevent such errors from being
 // top-leveled.
 /// A [Stream] wrapper that keeps track of whether it's been completed and
 /// whether it has any listeners.
 ///
 /// It also notifies its parent [ErrorGroup] when it completes successfully or
 /// receives an error.
-class _ErrorGroupStream extends Stream {
+class _ErrorGroupStream<T> extends Stream<T> {
   /// The parent [ErrorGroup].
   final ErrorGroup _group;
 
   /// Whether [this] has completed, either successfully or with an error.
   var _isDone = false;
 
   /// The underlying [StreamController] for [this].
-  final StreamController _controller;
+  final StreamController<T> _controller;
 
   /// The controller's [Stream].
   ///
   /// May be different than `_controller.stream` if the wrapped stream is a
   /// broadcasting stream.
-  Stream _stream;
+  Stream<T> _stream;
 
   /// The [StreamSubscription] that connects the wrapped [Stream] to
   /// [_controller].
-  StreamSubscription _subscription;
+  StreamSubscription<T> _subscription;
 
   /// Whether [this] has any listeners.
   bool get _hasListeners => _controller.hasListener;
 
   /// Creates a new [_ErrorGroupFuture] that's a child of [_group] and wraps
   /// [inner].
-  _ErrorGroupStream(this._group, Stream inner)
+  _ErrorGroupStream(this._group, Stream<T> inner)
     : _controller = new StreamController(sync: true) {
     // Use old-style asBroadcastStream behavior - cancel source _subscription
     // the first time the stream has no listeners.
     _stream = inner.isBroadcast
         ? _controller.stream.asBroadcastStream(onCancel: (sub) => sub.cancel())
         : _controller.stream;
     _subscription = inner.listen((v) {
       _controller.add(v);
     }, onError: (e, [stackTrace]) {
       _group._signalError(e, stackTrace);
     }, onDone: () {
       _isDone = true;
       _group._signalStreamComplete(this);
       _controller.close();
     });
   }
 
-  StreamSubscription listen(void onData(value),
+  StreamSubscription<T> listen(void onData(T value),
       {Function onError, void onDone(),
        bool cancelOnError}) {
     return _stream.listen(onData,
         onError: onError,
         onDone: onDone,
         cancelOnError: true);
   }
 
   /// Signal that an error from [_group] should be propagated through [this],
   /// unless it's already complete.
   void _signalError(var e, [StackTrace stackTrace]) {
     if (_isDone) return;
     _subscription.cancel();
     // Call these asynchronously to work around issue 7913.
     new Future.value().then((_) {
       _controller.addError(e, stackTrace);
       _controller.close();
     });
   }
 }