Rename Host* things to avoid name conflicts with bindings.

Author: sunfishcode

crates/wasi/src/preview2/host/instance_network.rs

@@ -1,10 +1,10 @@
 use crate::preview2::bindings::sockets::instance_network::{self, Network};
-use crate::preview2::network::{HostNetwork, TableNetworkExt};
+use crate::preview2::network::{HostNetworkState, TableNetworkExt};
 use crate::preview2::WasiView;
 
 impl<T: WasiView> instance_network::Host for T {
     fn instance_network(&mut self) -> Result<Network, anyhow::Error> {
-        let network = HostNetwork::new(self.ctx().pool.clone());
+        let network = HostNetworkState::new(self.ctx().pool.clone());
         let network = self.table_mut().push_network(network)?;
         Ok(network)
     }

crates/wasi/src/preview2/host/tcp.rs

@@ -7,7 +7,7 @@ use crate::preview2::bindings::{
 use crate::preview2::network::TableNetworkExt;
 use crate::preview2::poll::TablePollableExt;
 use crate::preview2::stream::TableStreamExt;
-use crate::preview2::tcp::{HostTcpSocket, HostTcpState, TableTcpSocketExt};
+use crate::preview2::tcp::{HostTcpSocketState, HostTcpState, TableTcpSocketExt};
 use crate::preview2::{HostPollable, PollableFuture, WasiView};
 use cap_net_ext::{Blocking, PoolExt, TcpListenerExt};
 use cap_std::net::TcpListener;
@@ -202,7 +202,7 @@ impl<T: WasiView> tcp::Host for T {
                 .as_socketlike_view::<TcpListener>()
                 .accept_with(Blocking::No)
         })?;
-        let mut tcp_socket = HostTcpSocket::from_tcp_stream(connection)?;
+        let mut tcp_socket = HostTcpSocketState::from_tcp_stream(connection)?;
 
         // Mark the socket as connected so that we can exit early from methods like `start-bind`.
         tcp_socket.tcp_state = HostTcpState::Connected;
@@ -415,7 +415,7 @@ impl<T: WasiView> tcp::Host for T {
     fn subscribe(&mut self, this: tcp::TcpSocket) -> anyhow::Result<Pollable> {
         fn make_tcp_socket_future<'a>(stream: &'a mut dyn Any) -> PollableFuture<'a> {
             let socket = stream
-                .downcast_mut::<HostTcpSocket>()
+                .downcast_mut::<HostTcpSocketState>()
                 .expect("downcast to HostTcpSocket failed");
 
             // Some states are ready immediately.

crates/wasi/src/preview2/host/tcp_create_socket.rs

@@ -3,15 +3,15 @@ use crate::preview2::bindings::{
     sockets::tcp::TcpSocket,
     sockets::tcp_create_socket,
 };
-use crate::preview2::tcp::{HostTcpSocket, TableTcpSocketExt};
+use crate::preview2::tcp::{HostTcpSocketState, TableTcpSocketExt};
 use crate::preview2::WasiView;
 
 impl<T: WasiView> tcp_create_socket::Host for T {
     fn create_tcp_socket(
         &mut self,
         address_family: IpAddressFamily,
     ) -> Result<TcpSocket, network::Error> {
-        let socket = HostTcpSocket::new(address_family.into())?;
+        let socket = HostTcpSocketState::new(address_family.into())?;
         let socket = self.table_mut().push_tcp_socket(socket)?;
         Ok(socket)
     }

crates/wasi/src/preview2/network.rs

@@ -1,32 +1,32 @@
 use crate::preview2::{Table, TableError};
 use cap_std::net::Pool;
 
-pub(crate) struct HostNetwork(pub(crate) Pool);
+pub(crate) struct HostNetworkState(pub(crate) Pool);
 
-impl HostNetwork {
+impl HostNetworkState {
     pub fn new(pool: Pool) -> Self {
         Self(pool)
     }
 }
 
 pub(crate) trait TableNetworkExt {
-    fn push_network(&mut self, network: HostNetwork) -> Result<u32, TableError>;
-    fn delete_network(&mut self, fd: u32) -> Result<HostNetwork, TableError>;
+    fn push_network(&mut self, network: HostNetworkState) -> Result<u32, TableError>;
+    fn delete_network(&mut self, fd: u32) -> Result<HostNetworkState, TableError>;
     fn is_network(&self, fd: u32) -> bool;
-    fn get_network(&self, fd: u32) -> Result<&HostNetwork, TableError>;
+    fn get_network(&self, fd: u32) -> Result<&HostNetworkState, TableError>;
 }
 
 impl TableNetworkExt for Table {
-    fn push_network(&mut self, network: HostNetwork) -> Result<u32, TableError> {
+    fn push_network(&mut self, network: HostNetworkState) -> Result<u32, TableError> {
         self.push(Box::new(network))
     }
-    fn delete_network(&mut self, fd: u32) -> Result<HostNetwork, TableError> {
+    fn delete_network(&mut self, fd: u32) -> Result<HostNetworkState, TableError> {
         self.delete(fd)
     }
     fn is_network(&self, fd: u32) -> bool {
-        self.is::<HostNetwork>(fd)
+        self.is::<HostNetworkState>(fd)
     }
-    fn get_network(&self, fd: u32) -> Result<&HostNetwork, TableError> {
+    fn get_network(&self, fd: u32) -> Result<&HostNetworkState, TableError> {
         self.get(fd)
     }
 }

crates/wasi/src/preview2/stdio.rs

@@ -110,25 +110,27 @@ impl<T: WasiView> stderr::Host for T {
     }
 }
 
-struct HostTerminalInput;
-struct HostTerminalOutput;
+struct HostTerminalInputState;
+struct HostTerminalOutputState;
 
 impl<T: WasiView> terminal_input::Host for T {
     fn drop_terminal_input(&mut self, r: terminal_input::TerminalInput) -> anyhow::Result<()> {
-        self.table_mut().delete::<HostTerminalInput>(r)?;
+        self.table_mut().delete::<HostTerminalInputState>(r)?;
         Ok(())
     }
 }
 impl<T: WasiView> terminal_output::Host for T {
     fn drop_terminal_output(&mut self, r: terminal_output::TerminalOutput) -> anyhow::Result<()> {
-        self.table_mut().delete::<HostTerminalOutput>(r)?;
+        self.table_mut().delete::<HostTerminalOutputState>(r)?;
         Ok(())
     }
 }
 impl<T: WasiView> terminal_stdin::Host for T {
     fn get_terminal_stdin(&mut self) -> anyhow::Result<Option<terminal_input::TerminalInput>> {
         if let IsATTY::Yes = self.ctx().stdin.isatty {
-            Ok(Some(self.table_mut().push(Box::new(HostTerminalInput))?))
+            Ok(Some(
+                self.table_mut().push(Box::new(HostTerminalInputState))?,
+            ))
         } else {
             Ok(None)
         }
@@ -137,7 +139,9 @@ impl<T: WasiView> terminal_stdin::Host for T {
 impl<T: WasiView> terminal_stdout::Host for T {
     fn get_terminal_stdout(&mut self) -> anyhow::Result<Option<terminal_output::TerminalOutput>> {
         if let IsATTY::Yes = self.ctx().stdout.isatty {
-            Ok(Some(self.table_mut().push(Box::new(HostTerminalOutput))?))
+            Ok(Some(
+                self.table_mut().push(Box::new(HostTerminalOutputState))?,
+            ))
         } else {
             Ok(None)
         }
@@ -146,7 +150,9 @@ impl<T: WasiView> terminal_stdout::Host for T {
 impl<T: WasiView> terminal_stderr::Host for T {
     fn get_terminal_stderr(&mut self) -> anyhow::Result<Option<terminal_output::TerminalOutput>> {
         if let IsATTY::Yes = self.ctx().stderr.isatty {
-            Ok(Some(self.table_mut().push(Box::new(HostTerminalOutput))?))
+            Ok(Some(
+                self.table_mut().push(Box::new(HostTerminalOutputState))?,
+            ))
         } else {
             Ok(None)
         }

crates/wasi/src/preview2/tcp.rs

@@ -43,8 +43,8 @@ pub(crate) enum HostTcpState {
 ///
 /// The inner state is wrapped in an Arc because the same underlying socket is
 /// used for implementing the stream types.
-pub(crate) struct HostTcpSocket {
-    /// The part of a `HostTcpSocket` which is reference-counted so that we
+pub(crate) struct HostTcpSocketState {
+    /// The part of a `HostTcpSocketState` which is reference-counted so that we
     /// can pass it to async tasks.
     pub(crate) inner: Arc<tokio::net::TcpStream>,
 
@@ -213,7 +213,7 @@ impl HostOutputStream for TcpWriteStream {
     }
 }
 
-impl HostTcpSocket {
+impl HostTcpSocketState {
     /// Create a new socket in the given family.
     pub fn new(family: AddressFamily) -> io::Result<Self> {
         // Create a new host socket and set it to non-blocking, which is needed
@@ -222,7 +222,7 @@ impl HostTcpSocket {
         Self::from_tcp_listener(tcp_listener)
     }
 
-    /// Create a `HostTcpSocket` from an existing socket.
+    /// Create a `HostTcpSocketState` from an existing socket.
     ///
     /// The socket must be in non-blocking mode.
     pub fn from_tcp_stream(tcp_socket: cap_std::net::TcpStream) -> io::Result<Self> {
@@ -254,27 +254,27 @@ impl HostTcpSocket {
 }
 
 pub(crate) trait TableTcpSocketExt {
-    fn push_tcp_socket(&mut self, tcp_socket: HostTcpSocket) -> Result<u32, TableError>;
-    fn delete_tcp_socket(&mut self, fd: u32) -> Result<HostTcpSocket, TableError>;
+    fn push_tcp_socket(&mut self, tcp_socket: HostTcpSocketState) -> Result<u32, TableError>;
+    fn delete_tcp_socket(&mut self, fd: u32) -> Result<HostTcpSocketState, TableError>;
     fn is_tcp_socket(&self, fd: u32) -> bool;
-    fn get_tcp_socket(&self, fd: u32) -> Result<&HostTcpSocket, TableError>;
-    fn get_tcp_socket_mut(&mut self, fd: u32) -> Result<&mut HostTcpSocket, TableError>;
+    fn get_tcp_socket(&self, fd: u32) -> Result<&HostTcpSocketState, TableError>;
+    fn get_tcp_socket_mut(&mut self, fd: u32) -> Result<&mut HostTcpSocketState, TableError>;
 }
 
 impl TableTcpSocketExt for Table {
-    fn push_tcp_socket(&mut self, tcp_socket: HostTcpSocket) -> Result<u32, TableError> {
+    fn push_tcp_socket(&mut self, tcp_socket: HostTcpSocketState) -> Result<u32, TableError> {
         self.push(Box::new(tcp_socket))
     }
-    fn delete_tcp_socket(&mut self, fd: u32) -> Result<HostTcpSocket, TableError> {
+    fn delete_tcp_socket(&mut self, fd: u32) -> Result<HostTcpSocketState, TableError> {
         self.delete(fd)
     }
     fn is_tcp_socket(&self, fd: u32) -> bool {
-        self.is::<HostTcpSocket>(fd)
+        self.is::<HostTcpSocketState>(fd)
     }
-    fn get_tcp_socket(&self, fd: u32) -> Result<&HostTcpSocket, TableError> {
+    fn get_tcp_socket(&self, fd: u32) -> Result<&HostTcpSocketState, TableError> {
         self.get(fd)
     }
-    fn get_tcp_socket_mut(&mut self, fd: u32) -> Result<&mut HostTcpSocket, TableError> {
+    fn get_tcp_socket_mut(&mut self, fd: u32) -> Result<&mut HostTcpSocketState, TableError> {
         self.get_mut(fd)
     }
 }