Make core libraries use generic method syntax.

sdk/lib/async/stream_impl.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;
 
 /** Abstract and private interface for a place to put events. */
 abstract class _EventSink<T> {
   void _add(T data);
   void _addError(Object error, StackTrace stackTrace);
@@ skipping 121 matching lines @@
       _pending.schedule(this);
     }
   }
 
   // StreamSubscription interface.
 
   void onData(void handleData(T event)) {
     if (handleData == null) handleData = _nullDataHandler;
     // TODO(floitsch): the return type should be 'void', and the type
     // should be inferred.
-    _onData = _zone.registerUnaryCallback/*<dynamic, T>*/(handleData);
+    _onData = _zone.registerUnaryCallback<dynamic, T>(handleData);
   }
 
   void onError(Function handleError) {
     if (handleError == null) handleError = _nullErrorHandler;
     // We are not allowed to use 'void' as type argument for the generic type,
     // so we use 'dynamic' instead.
-    _onError = _registerErrorHandler/*<dynamic>*/(handleError, _zone);
+    _onError = _registerErrorHandler<dynamic>(handleError, _zone);
   }
 
   void onDone(void handleDone()) {
     if (handleDone == null) handleDone = _nullDoneHandler;
     _onDone = _zone.registerCallback(handleDone);
   }
 
   void pause([Future resumeSignal]) {
     if (_isCanceled) return;
     bool wasPaused = _isPaused;
@@ skipping 26 matching lines @@
     // The user doesn't want to receive any further events. If there is an
     // error or done event pending (waiting for the cancel to be done) discard
     // that event.
     _state &= ~_STATE_WAIT_FOR_CANCEL;
     if (!_isCanceled) {
       _cancel();
     }
     return _cancelFuture ?? Future._nullFuture;
   }
 
-  Future/*<E>*/ asFuture/*<E>*/([var/*=E*/ futureValue]) {
-    _Future/*<E>*/ result = new _Future/*<E>*/();
+  Future<E> asFuture<E>([E futureValue]) {
+    _Future<E> result = new _Future<E>();
 
     // Overwrite the onDone and onError handlers.
     _onDone = () { result._complete(futureValue); };
     _onError = (error, stackTrace) {
       Future cancelFuture = cancel();
       if (!identical(cancelFuture, Future._nullFuture)) {
         cancelFuture.whenComplete(() {
           result._completeError(error, stackTrace);
         });
       } else {
@@ skipping 42 matching lines @@
   }
 
   // _EventSink interface.
 
   void _add(T data) {
     assert(!_isClosed);
     if (_isCanceled) return;
     if (_canFire) {
       _sendData(data);
     } else {
-      _addPending(new _DelayedData<dynamic /*=T*/>(data));
+      _addPending(new _DelayedData<T>(data));
     }
   }
 
   void _addError(Object error, StackTrace stackTrace) {
     if (_isCanceled) return;
     if (_canFire) {
       _sendError(error, stackTrace);  // Reports cancel after sending.
     } else {
       _addPending(new _DelayedError(error, stackTrace));
     }
@@ skipping 31 matching lines @@
 
   /**
    * Add a pending event.
    *
    * If the subscription is not paused, this also schedules a firing
    * of pending events later (if necessary).
    */
   void _addPending(_DelayedEvent event) {
     _StreamImplEvents<T> pending = _pending;
     if (_pending == null) {
-      pending = _pending = new _StreamImplEvents<dynamic /*=T*/>();
+      pending = _pending = new _StreamImplEvents<T>();
     }
     pending.add(event);
     if (!_hasPending) {
       _state |= _STATE_HAS_PENDING;
       if (!_isPaused) {
         _pending.schedule(this);
       }
     }
   }
 
@@ skipping 19 matching lines @@
     void sendError() {
       // If the subscription has been canceled while waiting for the cancel
       // future to finish we must not report the error.
       if (_isCanceled && !_waitsForCancel) return;
       _state |= _STATE_IN_CALLBACK;
       if (_onError is ZoneBinaryCallback<dynamic, Object, StackTrace>) {
         ZoneBinaryCallback<dynamic, Object, StackTrace> errorCallback = _onError
             as Object /*=ZoneBinaryCallback<dynamic, Object, StackTrace>*/;
         _zone.runBinaryGuarded(errorCallback, error, stackTrace);
       } else {
-        _zone.runUnaryGuarded/*<dynamic, dynamic>*/(
+        _zone.runUnaryGuarded<dynamic, dynamic>(
             _onError as Object /*=ZoneUnaryCallback<dynamic, dynamic>*/, error);
       }
       _state &= ~_STATE_IN_CALLBACK;
     }
 
     if (_cancelOnError) {
       _state |= _STATE_WAIT_FOR_CANCEL;
       _cancel();
       if (_cancelFuture is Future &&
           !identical(_cancelFuture, Future._nullFuture)) {
@@ skipping 390 matching lines @@
     if (isPaused) {
       _state -= _PAUSED;
       if (!isPaused && !_isSent) {
         _schedule();
       }
     }
   }
 
   Future cancel() => Future._nullFuture;
 
-  Future/*<E>*/ asFuture/*<E>*/([var/*=E*/ futureValue]) {
-    _Future/*<E>*/ result = new _Future/*<E>*/();
+  Future<E> asFuture<E>([E futureValue]) {
+    _Future<E> result = new _Future<E>();
     _onDone = () { result._completeWithValue(null); };
     return result;
   }
 
   void _sendDone() {
     _state &= ~_SCHEDULED;
     if (isPaused) return;
     _state |= _DONE_SENT;
     if (_onDone != null) _zone.runGuarded(_onDone);
   }
 }
 
 class _AsBroadcastStream<T> extends Stream<T> {
   final Stream<T> _source;
   final _BroadcastCallback<T> _onListenHandler;
   final _BroadcastCallback<T> _onCancelHandler;
   final Zone _zone;
 
   _AsBroadcastStreamController<T> _controller;
   StreamSubscription<T> _subscription;
 
   _AsBroadcastStream(this._source,
                      void onListenHandler(StreamSubscription<T> subscription),
                      void onCancelHandler(StreamSubscription<T> subscription))
       // TODO(floitsch): the return type should be void and should be
       // inferred.
       : _onListenHandler = Zone.current.registerUnaryCallback
-            /*<dynamic, StreamSubscription<T>>*/(onListenHandler),
+            <dynamic, StreamSubscription<T>>(onListenHandler),
         _onCancelHandler = Zone.current.registerUnaryCallback
-            /*<dynamic, StreamSubscription<T>>*/(onCancelHandler),
+            <dynamic, StreamSubscription<T>>(onCancelHandler),
         _zone = Zone.current {
     _controller = new _AsBroadcastStreamController<T>(_onListen, _onCancel);
   }
 
   bool get isBroadcast => true;
 
   StreamSubscription<T> listen(void onData(T data),
                                { Function onError,
                                  void onDone(),
                                  bool cancelOnError}) {
@@ skipping 91 matching lines @@
 
   Future cancel() {
     _stream._cancelSubscription();
     return Future._nullFuture;
   }
 
   bool get isPaused {
     return _stream._isSubscriptionPaused;
   }
 
-  Future/*<E>*/ asFuture/*<E>*/([var/*=E*/ futureValue]) {
+  Future<E> asFuture<E>([E futureValue]) {
     throw new UnsupportedError(
         "Cannot change handlers of asBroadcastStream source subscription.");
   }
 }
 
 
 /**
  * Simple implementation of [StreamIterator].
  *
  * Pauses the stream between calls to [moveNext].
@@ skipping 135 matching lines @@
 class _EmptyStream<T> extends Stream<T> {
   const _EmptyStream() : super._internal();
   bool get isBroadcast => true;
   StreamSubscription<T> listen(void onData(T data),
                                {Function onError,
                                 void onDone(),
                                 bool cancelOnError}) {
     return new _DoneStreamSubscription<T>(onDone);
   }
 }