Fix analyzer warnings!

pkg/async/lib/result.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.
 
 /**
  * Capture asynchronous results into synchronous values, and release them again.
  *
  * Capturing a result (either a returned value or a thrown error)
  * means converting it into a [Result] -
  * either a [ValueResult] or an [ErrorResult].
@@ skipping 180 matching lines @@
   /** The thrown object that this result represents. */
   final error;
   /** The stack trace, if any, associated with the throw. */
   final StackTrace stackTrace;
   /** Create an error result with the given [error] and [stackTrace]. */
   ErrorResult(this.error, this.stackTrace);
   bool get isValue => false;
   bool get isError => true;
   ValueResult get asValue => null;
   ErrorResult get asError => this;
-  void complete(Completer<T> completer) {
+  void complete(Completer completer) {
     completer.completeError(error, stackTrace);
   }
-  void addTo(EventSink<T> sink) {
+  void addTo(EventSink sink) {
     sink.addError(error, stackTrace);
   }
   Future get asFuture => new Future.error(error, stackTrace);
 }
 
 /**
  * A stream transformer that captures a stream of events into [Result]s.
  *
  * The result of the transformation is a stream of [Result] values and
  * no error events.
@@ skipping 16 matching lines @@
  * The result of the transformation is a stream of values and
  * error events.
  */
 class ReleaseStreamTransformer<T> implements StreamTransformer<Result<T>, T> {
   const ReleaseStreamTransformer();
 
   Stream<T> bind(Stream<Result<T>> source) {
     return new Stream<T>.eventTransformed(source, _createSink);
   }
 
-  static EventSink _createSink(EventSink<Result> sink) {
+  static EventSink<Result> _createSink(EventSink sink) {
     return new ReleaseSink(sink);
   }
 }
 
 /**
  * An event sink wrapper that captures the incoming events.
  *
  * Wraps an [EventSink] that expects [Result] values.
  * Accepts any value and error result,
  * and passes them to the wrapped sink as [Result] values.
  *
  * The wrapped sink will never receive an error event.
  */
 class CaptureSink<T> implements EventSink<T> {
   final EventSink _sink;
 
   CaptureSink(EventSink<Result<T>> sink) : _sink = sink;
   void add(T value) { _sink.add(new ValueResult(value)); }
-  void addError(Object error, StackTrace stackTrace) {
+  void addError(Object error, [StackTrace stackTrace]) {
     _sink.add(new ErrorResult(error, stackTrace));
   }
   void close() { _sink.close(); }
 }
 
 /**
  * An event sink wrapper that releases the incoming result events.
  *
  * Wraps an output [EventSink] that expects any result.
  * Accepts [Result] values, and puts the result value or error into the
  * corresponding output sink add method.
  */
 class ReleaseSink<T> implements EventSink<Result<T>> {
   final EventSink _sink;
   ReleaseSink(EventSink<T> sink) : _sink = sink;
   void add(Result<T> result) {
     if (result.isValue) {
       _sink.add(result.asValue.value);
     } else {
       ErrorResult error = result.asError;
       _sink.addError(error.error, error.stackTrace);
     }
   }
-  void addError(Object error, StackTrace stackTrace) {
+  void addError(Object error, [StackTrace stackTrace]) {
     // Errors may be added by intermediate processing, even if it is never
     // added by CaptureSink.
     _sink.addError(error, stackTrace);
   }
 
   void close() { _sink.close(); }
 }