Fix a couple of doc comment references - and many spelling mistakes

sdk/lib/async/future.dart

 // Copyright (c) 2012, 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.
 
 part of dart.async;
 
 /// A type representing values that are either `Future<T>` or `T`.
 ///
 /// This class declaration is a public stand-in for an internal
 /// future-or-value generic type. References to this class are resolved to the
@@ skipping 318 matching lines @@
    * then the returned future completes with that error.
    * If further futures also complete with errors, those errors are discarded.
    *
    * If `eagerError` is true, the returned future completes with an error
    * immediately on the first error from one of the futures. Otherwise all
    * futures must complete before the returned future is completed (still with
    * the first error; the remaining errors are silently dropped).
    *
    * In the case of an error, [cleanUp] (if provided), is invoked on any
    * non-null result of successful futures.
-   * This makes it posible to `cleanUp` resources that would otherwise be
+   * This makes it possible to `cleanUp` resources that would otherwise be
    * lost (since the returned future does not provide access to these values).
    * The [cleanUp] function is unused if there is no error.
    *
    * The call to [cleanUp] should not throw. If it does, the error will be an
    * uncaught asynchronous error.
    */
   static Future<List<T>> wait<T>(Iterable<Future<T>> futures,
       {bool eagerError: false, void cleanUp(T successValue)}) {
     final _Future<List<T>> result = new _Future<List<T>>();
     List<T> values; // Collects the values. Set to null on error.
@@ skipping 136 matching lines @@
       return true;
     });
   }
 
   // Constant `true` function, used as callback by [forEach].
   static bool _kTrue(_) => true;
 
   /**
    * Performs an operation repeatedly until it returns `false`.
    *
-   * The operation, [f], may be either synchronous or asynchronous.
+   * The operation, [action], may be either synchronous or asynchronous.
    *
    * The operation is called repeatedly as long as it returns either the [bool]
    * value `true` or a `Future<bool>` which completes with the value `true`.
    *
-   * If a call to [f] returns `false` or a [Future] that completes to `false`,
-   * iteration ends and the future returned by [doWhile] is completed with
-   * a `null` value.
+   * If a call to [action] returns `false` or a [Future] that completes to
+   * `false`, iteration ends and the future returned by [doWhile] is completed
+   * with a `null` value.
    *
-   * If a call to [f] throws or a future returned by [f] completes with
-   * an error, iteration ends and the future returned by [doWhile]
+   * If a call to [action] throws or a future returned by [action] completes
+   * with an error, iteration ends and the future returned by [doWhile]
    * completes with the same error.
    *
    * Calls to [action] may happen at any time,
    * including immediately after calling `doWhile`.
    * The only restriction is a new call to [action] won't happen before
    * the previous call has returned, and if it returned a `Future<bool>`, not
    * until that future has completed.
    */
   static Future doWhile(FutureOr<bool> action()) {
     _Future doneSignal = new _Future();
@@ skipping 392 matching lines @@
   AsyncError replacement = Zone.current.errorCallback(error, stackTrace);
   if (replacement != null) {
     error = _nonNullError(replacement.error);
     stackTrace = replacement.stackTrace;
   }
   result._asyncCompleteError(error, stackTrace);
 }
 
 /** Helper function that converts `null` to a [NullThrownError]. */
 Object _nonNullError(Object error) => error ?? new NullThrownError();