Make core libraries use generic method syntax.

sdk/lib/io/secure_socket.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.
 
 part of dart.io;
 
 /**
  * A high-level class for communicating securely over a TCP socket, using
  * TLS and SSL. The [SecureSocket] exposes both a [Stream] and an
  * [IOSink] interface, making it ideal for using together with
@@ skipping 57 matching lines @@
    *
    * See [connect] for more information on the arguments.
    *
    */
   static Future<SecureSocket> secure(
       Socket socket,
       {host,
        SecurityContext context,
        bool onBadCertificate(X509Certificate certificate)}) {
     return ((socket as dynamic/*_Socket*/)._detachRaw() as Future)
-        .then/*<RawSecureSocket>*/((detachedRaw) {
+        .then<RawSecureSocket>((detachedRaw) {
           return RawSecureSocket.secure(
             detachedRaw[0] as RawSocket,
             subscription: detachedRaw[1] as StreamSubscription<RawSocketEvent>,
             host: host,
             context: context,
             onBadCertificate: onBadCertificate);
           })
-        .then/*<SecureSocket>*/((raw) => new SecureSocket._(raw));
+        .then<SecureSocket>((raw) => new SecureSocket._(raw));
  }
 
   /**
    * Takes an already connected [socket] and starts server side TLS
    * handshake to make the communication secure. When the returned
    * future completes the [SecureSocket] has completed the TLS
    * handshake. Using this function requires that the other end of the
    * connection is going to start the TLS handshake.
    *
    * If the [socket] already has a subscription, this subscription
@@ skipping 11 matching lines @@
    *
    */
   static Future<SecureSocket> secureServer(
       Socket socket,
       SecurityContext context,
       {List<int> bufferedData,
        bool requestClientCertificate: false,
        bool requireClientCertificate: false,
        List<String> supportedProtocols}) {
     return ((socket as dynamic/*_Socket*/)._detachRaw() as Future)
-        .then/*<RawSecureSocket>*/((detachedRaw) {
+        .then<RawSecureSocket>((detachedRaw) {
           return RawSecureSocket.secureServer(
             detachedRaw[0] as RawSocket,
             context,
             subscription: detachedRaw[1] as StreamSubscription<RawSocketEvent>,
             bufferedData: bufferedData,
             requestClientCertificate: requestClientCertificate,
             requireClientCertificate: requireClientCertificate,
             supportedProtocols: supportedProtocols);
           })
-        .then/*<SecureSocket>*/((raw) => new SecureSocket._(raw));
+        .then<SecureSocket>((raw) => new SecureSocket._(raw));
   }
 
   /**
    * Get the peer certificate for a connected SecureSocket.  If this
    * SecureSocket is the server end of a secure socket connection,
    * [peerCertificate] will return the client certificate, or null, if no
    * client certificate was received.  If it is the client end,
    * [peerCertificate] will return the server's certificate.
    */
   X509Certificate get peerCertificate;
@@ skipping 1109 matching lines @@
 /**
  * An exception that happens in the handshake phase of establishing
  * a secure network connection, when looking up or verifying a
  * certificate.
  */
 class CertificateException extends TlsException {
   const CertificateException([String message = "",
                             OSError osError = null])
      : super._("CertificateException", message, osError);
 }