remove calls to futures::executor::block_on (#4760)

1 files changed, 22 insertions, 52 deletions

diff --git a/cli/resolve_addr.rs b/cli/resolve_addr.rs
index db06e1136..3081ef431 100644
--- a/cli/resolve_addr.rs
+++ b/cli/resolve_addr.rs
@@ -1,63 +1,33 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
 use crate::op_error::OpError;
-use std::future::Future;
 use std::net::SocketAddr;
 use std::net::ToSocketAddrs;
-use std::pin::Pin;
-use std::task::Context;
-use std::task::Poll;
 
 /// Resolve network address. Returns a future.
-pub fn resolve_addr(hostname: &str, port: u16) -> ResolveAddrFuture {
-  ResolveAddrFuture {
-    hostname: hostname.to_string(),
-    port,
-  }
-}
-
-pub struct ResolveAddrFuture {
-  hostname: String,
-  port: u16,
-}
-
-impl Future for ResolveAddrFuture {
-  type Output = Result<SocketAddr, OpError>;
+pub fn resolve_addr(hostname: &str, port: u16) -> Result<SocketAddr, OpError> {
+  // Default to localhost if given just the port. Example: ":80"
+  let addr: &str = if !hostname.is_empty() {
+    &hostname
+  } else {
+    "0.0.0.0"
+  };
 
-  fn poll(self: Pin<&mut Self>, _cx: &mut Context) -> Poll<Self::Output> {
-    let inner = self.get_mut();
-    // The implementation of this is not actually async at the moment,
-    // however we intend to use async DNS resolution in the future and
-    // so we expose this as a future instead of Result.
-
-    // Default to localhost if given just the port. Example: ":80"
-    let addr: &str = if !inner.hostname.is_empty() {
-      &inner.hostname
-    } else {
-      "0.0.0.0"
-    };
-
-    // If this looks like an ipv6 IP address. Example: "[2001:db8::1]"
-    // Then we remove the brackets.
-    let addr = if addr.starts_with('[') && addr.ends_with(']') {
-      let l = addr.len() - 1;
-      addr.get(1..l).unwrap()
-    } else {
-      addr
-    };
-    let addr_port_pair = (addr, inner.port);
-    let r = addr_port_pair.to_socket_addrs().map_err(OpError::from);
-
-    Poll::Ready(r.and_then(|mut iter| match iter.next() {
-      Some(a) => Ok(a),
-      None => panic!("There should be at least one result"),
-    }))
-  }
+  // If this looks like an ipv6 IP address. Example: "[2001:db8::1]"
+  // Then we remove the brackets.
+  let addr = if addr.starts_with('[') && addr.ends_with(']') {
+    let l = addr.len() - 1;
+    addr.get(1..l).unwrap()
+  } else {
+    addr
+  };
+  let addr_port_pair = (addr, port);
+  let mut iter = addr_port_pair.to_socket_addrs().map_err(OpError::from)?;
+  Ok(iter.next().unwrap())
 }
 
 #[cfg(test)]
 mod tests {
   use super::*;
-  use futures::executor::block_on;
   use std::net::Ipv4Addr;
   use std::net::Ipv6Addr;
   use std::net::SocketAddrV4;
@@ -67,7 +37,7 @@ mod tests {
   fn resolve_addr1() {
     let expected =
       SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 80));
-    let actual = block_on(resolve_addr("127.0.0.1", 80)).unwrap();
+    let actual = resolve_addr("127.0.0.1", 80).unwrap();
     assert_eq!(actual, expected);
   }
 
@@ -75,7 +45,7 @@ mod tests {
   fn resolve_addr2() {
     let expected =
       SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(0, 0, 0, 0), 80));
-    let actual = block_on(resolve_addr("", 80)).unwrap();
+    let actual = resolve_addr("", 80).unwrap();
     assert_eq!(actual, expected);
   }
 
@@ -83,7 +53,7 @@ mod tests {
   fn resolve_addr3() {
     let expected =
       SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(192, 0, 2, 1), 25));
-    let actual = block_on(resolve_addr("192.0.2.1", 25)).unwrap();
+    let actual = resolve_addr("192.0.2.1", 25).unwrap();
     assert_eq!(actual, expected);
   }
 
@@ -95,7 +65,7 @@ mod tests {
       0,
       0,
     ));
-    let actual = block_on(resolve_addr("[2001:db8::1]", 8080)).unwrap();
+    let actual = resolve_addr("[2001:db8::1]", 8080).unwrap();
     assert_eq!(actual, expected);
   }
 }