Fix type errors caught by analyzer.

lib/src/stream_queue.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.
 
 library async.stream_events;
 
 import 'dart:async';
 import 'dart:collection';
 
 import "subscription_stream.dart";
@@ skipping 268 matching lines @@
       if (request.addEvents(_eventQueue)) return;
       _ensureListening();
     }
     _requestQueue.add(request);
 
   }
 
   /// Ensures that we are listening on events from [_sourceStream].
   ///
   /// Resumes subscription on [_sourceStream], or creates it if necessary.
-  StreamSubscription _ensureListening() {
+  void _ensureListening() {
     assert(!_isDone);
     if (_subscription == null) {
       _subscription =
           _sourceStream.listen(_onData, onError: _onError, onDone: _onDone);
     } else {
       _subscription.resume();
     }
   }
 
   /// Removes all requests and closes them.
@@ skipping 47 matching lines @@
 ///
 /// Events from the source stream are sent to the first request in the
 /// queue until it reports itself as [isComplete].
 ///
 /// When the first request in the queue `isComplete`, either when becoming
 /// the first request or after receiving an event, its [close] methods is
 /// called.
 ///
 /// The [close] method is also called immediately when the source stream
 /// is done.
-abstract class _EventRequest implements EventSink {
+abstract class _EventRequest {
   /// Handle available events.
   ///
   /// The available events are provided as a queue. The `addEvents` function
   /// should only remove events from the front of the event queue, e.g.,
   /// using [removeFirst].
   ///
   /// Returns `true` if the request is completed, or `false` if it needs
   /// more events.
   /// The call may keep events in the queue until the requeust is complete,
   /// or it may remove them immediately.
@@ skipping 96 matching lines @@
   ///
   /// The request [isComplete] when the length of [_list] reaches
   /// this value.
   final int _eventsToTake;
 
   _TakeRequest(this._eventsToTake) : _completer = new Completer<List<T>>();
 
   /// The future completed when the correct number of events have been captured.
   Future get future => _completer.future;
 
-  bool addEvents(Queue<Events> events) {
+  bool addEvents(Queue<Result> events) {
     while (_list.length < _eventsToTake) {
       if (events.isEmpty) return false;
       var result = events.removeFirst();
       if (result.isError) {
         result.complete(_completer);
         return true;
       }
       _list.add(result.asValue.value);
     }
     _completer.complete(_list);
     return true;
   }
 
-  void close(Queue<Events> events) {
+  void close(Queue<Result> events) {
     _completer.complete(_list);
   }
 }
 
 /// Request for a [StreamQueue.cancel] call.
 ///
 /// The request needs no events, it just waits in the request queue
 /// until all previous events are fulfilled, then it cancels the stream queue
 /// source subscription.
 class _CancelRequest implements _EventRequest {
@@ skipping 111 matching lines @@
       _completer.complete(true);
       return true;
     }
     return false;
   }
 
   void close(_) {
     _completer.complete(false);
   }
 }