Make core libraries use generic method syntax.

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 276 matching lines @@
    * complete before the returned future is completed (still with the first
    * error to occur, the remaining errors are silently dropped).
    *
    * If [cleanUp] is provided, in the case of an error, any non-null result of
    * a successful future is passed to `cleanUp`, which can then release any
    * resources that the successful operation allocated.
    *
    * 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,
+  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.
+                            void cleanUp(T successValue)}) {
+    final _Future<List<T>> result = new _Future<List<T>>();
+    List<T> values;  // Collects the values. Set to null on error.
     int remaining = 0;  // How many futures are we waiting for.
     var error;   // The first error from a future.
     StackTrace stackTrace;  // The stackTrace that came with the error.
 
     // Handle an error from any of the futures.
     void handleError(theError, theStackTrace) {
       remaining--;
       if (values != null) {
         if (cleanUp != null) {
           for (var value in values) {
@@ skipping 13 matching lines @@
       } else if (remaining == 0 && !eagerError) {
         result._completeError(error, stackTrace);
       }
     }
 
     try {
       // As each future completes, put its value into the corresponding
       // position in the list of values.
       for (Future future in futures) {
         int pos = remaining;
-        future.then((Object/*=T*/ value) {
+        future.then((T value) {
           remaining--;
           if (values != null) {
             values[pos] = value;
             if (remaining == 0) {
               result._completeWithValue(values);
             }
           } else {
             if (cleanUp != null && value != null) {
               // Ensure errors from cleanUp are uncaught.
               new Future.sync(() { cleanUp(value); });
             }
             if (remaining == 0 && !eagerError) {
               result._completeError(error, stackTrace);
             }
           }
         }, onError: handleError);
         // Increment the 'remaining' after the call to 'then'.
         // If that call throws, we don't expect any future callback from
         // the future, and we also don't increment remaining.
         remaining++;
       }
       if (remaining == 0) {
         return new Future.value(const []);
       }
-      values = new List/*<T>*/(remaining);
+      values = new List<T>(remaining);
     } catch (e, st) {
       // The error must have been thrown while iterating over the futures
       // list, or while installing a callback handler on the future.
       if (remaining == 0 || eagerError) {
         // Throw a new Future.error.
         // Don't just call `result._completeError` since that would propagate
         // the error too eagerly, not giving the callers time to install
         // error handlers.
         // Also, don't use `_asyncCompleteError` since that one doesn't give
         // zones the chance to intercept the error.
@@ skipping 12 matching lines @@
   /**
    * Returns the result of the first future in [futures] to complete.
    *
    * The returned future is completed with the result of the first
    * future in [futures] to report that it is complete.
    * The results of all the other futures are discarded.
    *
    * If [futures] is empty, or if none of its futures complete,
    * the returned future never completes.
    */
-  static Future/*<T>*/ any/*<T>*/(Iterable<Future/*<T>*/> futures) {
-    var completer = new Completer/*<T>*/.sync();
-    var onValue = (/*=T*/ value) {
+  static Future<T> any<T>(Iterable<Future<T>> futures) {
+    var completer = new Completer<T>.sync();
+    var onValue = (T value) {
       if (!completer.isCompleted) completer.complete(value);
     };
     var onError = (error, stack) {
       if (!completer.isCompleted) completer.completeError(error, stack);
     };
     for (var future in futures) {
       future.then(onValue, onError: onError);
     }
     return completer.future;
   }
@@ skipping 84 matching lines @@
    * the future returned by `then` will be completed with
    * the same result as the future returned by the callback.
    *
    * If [onError] is not given, and this future completes with an error,
    * the error is forwarded directly to the returned future.
    *
    * In most cases, it is more readable to use [catchError] separately, possibly
    * with a `test` parameter, instead of handling both value and error in a
    * single [then] call.
    */
-  Future/*<S>*/ then/*<S>*/(onValue(T value), { Function onError });
+  Future<S> then<S>(onValue(T value), { Function onError });
 
   /**
    * Handles errors emitted by this [Future].
    *
    * This is the asynchronous equivalent of a "catch" block.
    *
    * Returns a new [Future] that will be completed with either the result of
    * this future or the result of calling the `onError` callback.
    *
    * If this future completes with a value,
@@ skipping 42 matching lines @@
    */
   // The `Function` below can stand for several types:
   // - (dynamic) -> T
   // - (dynamic, StackTrace) -> T
   // - (dynamic) -> Future<T>
   // - (dynamic, StackTrace) -> Future<T>
   // Given that there is a `test` function that is usually used to do an
   // `isCheck` we should also expect functions that take a specific argument.
   // Note: making `catchError` return a `Future<T>` in non-strong mode could be
   // a breaking change.
-  Future/*<T>*/ catchError(Function onError,
+  Future<T> catchError(Function onError,
                            {bool test(Object error)});
 
   /**
    * Register a function to be called when this future completes.
    *
    * The [action] function is called when this future completes, whether it
    * does so with a value or with an error.
    *
    * This is the asynchronous equivalent of a "finally" block.
    *
@@ skipping 246 matching lines @@
   if (replacement != null) {
     error = _nonNullError(replacement.error);
     stackTrace = replacement.stackTrace;
   }
   result._completeError(error, stackTrace);
 }
 
 /** Helper function that converts `null` to a [NullThrownError]. */
 Object _nonNullError(Object error) =>
   (error != null) ? error : new NullThrownError();