Remove explicit DNS lookups from JS IP socket connect & bind

Author: mpilquist

io/js/src/main/scala/fs2/io/net/AsyncSocketsProvider.scala

@@ -27,7 +27,7 @@ import cats.effect.{Async, Resource}
 import cats.effect.std.Dispatcher
 import cats.effect.syntax.all._
 import cats.syntax.all._
-import com.comcast.ip4s.{IpAddress, Port, SocketAddress, UnixSocketAddress}
+import com.comcast.ip4s.{Host, IpAddress, Port, SocketAddress, UnixSocketAddress}
 import fs2.concurrent.Channel
 import fs2.io.internal.facade
 
@@ -39,7 +39,7 @@ private[net] abstract class AsyncSocketsProvider[F[_]](implicit F: Async[F]) {
     options.traverse_(option => option.key.set(socket, option.value))
 
   protected def connectIpOrUnix(
-      to: Either[SocketAddress[IpAddress], UnixSocketAddress],
+      to: Either[SocketAddress[Host], UnixSocketAddress],
       options: List[SocketOption]
   ): Resource[F, Socket[F]] =
     (for {
@@ -92,7 +92,7 @@ private[net] abstract class AsyncSocketsProvider[F[_]](implicit F: Async[F]) {
     } yield socket).adaptError { case IOException(ex) => ex }
 
   protected def bindIpOrUnix(
-      address: Either[SocketAddress[IpAddress], UnixSocketAddress],
+      address: Either[SocketAddress[Host], UnixSocketAddress],
       options: List[SocketOption]
   ): Resource[F, ServerSocket[F]] =
     (for {
@@ -125,7 +125,7 @@ private[net] abstract class AsyncSocketsProvider[F[_]](implicit F: Async[F]) {
           } <* F.delay {
             address match {
               case Left(addr) =>
-                if (addr.host.isWildcard)
+                if (addr.host.isInstanceOf[IpAddress] && addr.host.asInstanceOf[IpAddress].isWildcard)
                   server.listen(addr.port.value, () => cb(Right(())))
                 else
                   server.listen(addr.port.value, addr.host.toString, () => cb(Right(())))

io/js/src/main/scala/fs2/io/net/IpSocketsProviderPlatform.scala

@@ -24,30 +24,23 @@ package io
 package net
 
 import cats.effect.{Async, Resource}
-import com.comcast.ip4s.{Dns, Host, SocketAddress}
+import com.comcast.ip4s.{Host, SocketAddress}
 
 private[net] trait IpSocketsProviderCompanionPlatform { self: IpSocketsProvider.type =>
 
   private[net] def forAsync[F[_]: Async]: IpSocketsProvider[F] =
-    forAsyncAndDns[F](implicitly, Dns.forAsync)
-
-  private def forAsyncAndDns[F[_]: Async: Dns]: IpSocketsProvider[F] =
     new AsyncSocketsProvider[F] with IpSocketsProvider[F] {
 
       override def connect(
           address: SocketAddress[Host],
           options: List[SocketOption]
       ): Resource[F, Socket[F]] =
-        Resource.eval(address.host.resolve[F]).flatMap { ip =>
-          connectIpOrUnix(Left(SocketAddress(ip, address.port)), options)
-        }
+        connectIpOrUnix(Left(address), options)
 
       override def bind(
           address: SocketAddress[Host],
           options: List[SocketOption]
       ): Resource[F, ServerSocket[F]] =
-        Resource.eval(address.host.resolve[F]).flatMap { ip =>
-          bindIpOrUnix(Left(SocketAddress(ip, address.port)), options)
-        }
+        bindIpOrUnix(Left(address), options)
     }
 }