Merge pull request #220 from alexcrichton/less-generics

Simplify some generics in type signatures

Author: alexcrichton

crates/misc/component-async-tests/src/resource_stream.rs

@@ -65,7 +65,7 @@ impl bindings::local::local::resource_stream::HostConcurrent for Ctx {
 
         let (tx, rx) = accessor.with(|mut view| {
             let instance = view.instance();
-            instance.stream::<_, _, Option<_>, _, _>(&mut view)
+            instance.stream::<_, _, Option<_>>(&mut view)
         })?;
         accessor.spawn(Task { tx, count });
         Ok(rx.into())

crates/misc/component-async-tests/tests/scenario/streams.rs

@@ -46,46 +46,46 @@ pub async fn async_watch_streams() -> Result<()> {
     let instance = linker.instantiate_async(&mut store, &component).await?;
 
     // Test watching and then dropping the read end of a stream.
-    let (tx, rx) = instance.stream::<u8, Option<_>, Option<_>, _, _>(&mut store)?;
+    let (tx, rx) = instance.stream::<u8, Option<_>, Option<_>>(&mut store)?;
     let watch = tx.watch_reader().0;
     drop(rx);
     instance.run(&mut store, watch).await?;
 
     // Test dropping and then watching the read end of a stream.
-    let (tx, rx) = instance.stream::<u8, Option<_>, Option<_>, _, _>(&mut store)?;
+    let (tx, rx) = instance.stream::<u8, Option<_>, Option<_>>(&mut store)?;
     drop(rx);
     instance.run(&mut store, tx.watch_reader().0).await?;
 
     // Test watching and then dropping the write end of a stream.
-    let (tx, rx) = instance.stream::<u8, Option<_>, Option<_>, _, _>(&mut store)?;
+    let (tx, rx) = instance.stream::<u8, Option<_>, Option<_>>(&mut store)?;
     let watch = rx.watch_writer().0;
     drop(tx);
     instance.run(&mut store, watch).await?;
 
     // Test dropping and then watching the write end of a stream.
-    let (tx, rx) = instance.stream::<u8, Option<_>, Option<_>, _, _>(&mut store)?;
+    let (tx, rx) = instance.stream::<u8, Option<_>, Option<_>>(&mut store)?;
     drop(tx);
     instance.run(&mut store, rx.watch_writer().0).await?;
 
     // Test watching and then dropping the read end of a future.
-    let (tx, rx) = instance.future::<u8, _, _>(|| 42, &mut store)?;
+    let (tx, rx) = instance.future::<u8>(|| 42, &mut store)?;
     let watch = tx.watch_reader().0;
     drop(rx);
     instance.run(&mut store, watch).await?;
 
     // Test dropping and then watching the read end of a future.
-    let (tx, rx) = instance.future::<u8, _, _>(|| 42, &mut store)?;
+    let (tx, rx) = instance.future::<u8>(|| 42, &mut store)?;
     drop(rx);
     instance.run(&mut store, tx.watch_reader().0).await?;
 
     // Test watching and then dropping the write end of a future.
-    let (tx, rx) = instance.future::<u8, _, _>(|| 42, &mut store)?;
+    let (tx, rx) = instance.future::<u8>(|| 42, &mut store)?;
     let watch = rx.watch_writer().0;
     drop(tx);
     instance.run(&mut store, watch).await?;
 
     // Test dropping and then watching the write end of a future.
-    let (tx, rx) = instance.future::<u8, _, _>(|| 42, &mut store)?;
+    let (tx, rx) = instance.future::<u8>(|| 42, &mut store)?;
     drop(tx);
     instance.run(&mut store, rx.watch_writer().0).await?;
 
@@ -293,7 +293,7 @@ pub async fn test_closed_streams(watch: bool) -> Result<()> {
 
     // Next, test stream host->guest
     {
-        let (tx, rx) = instance.stream::<_, _, Vec<_>, _, _>(&mut store)?;
+        let (tx, rx) = instance.stream::<_, _, Vec<_>>(&mut store)?;
 
         let mut futures = FuturesUnordered::new();
         futures.push(

crates/misc/component-async-tests/tests/scenario/transmit.rs

@@ -358,9 +358,8 @@ async fn test_transmit_with<Test: TransmitTest + 'static>(component: &str) -> Re
         ReadNone(Option<StreamReader<Option<String>>>),
     }
 
-    let (control_tx, control_rx) = instance.stream::<_, _, Option<_>, _, _>(&mut store)?;
-    let (caller_stream_tx, caller_stream_rx) =
-        instance.stream::<_, _, Option<_>, _, _>(&mut store)?;
+    let (control_tx, control_rx) = instance.stream::<_, _, Option<_>>(&mut store)?;
+    let (caller_stream_tx, caller_stream_rx) = instance.stream::<_, _, Option<_>>(&mut store)?;
     let (caller_future1_tx, caller_future1_rx) = instance.future(|| unreachable!(), &mut store)?;
     let (_caller_future2_tx, caller_future2_rx) = instance.future(|| unreachable!(), &mut store)?;
 

crates/wasi-http/src/p3/host/types.rs

@@ -790,7 +790,7 @@ where
         store.with(|mut view| {
             let instance = view.instance();
             let (contents_tx, contents_rx) = instance
-                .stream::<_, _, Vec<_>, _, _>(&mut view)
+                .stream::<_, _, Vec<_>>(&mut view)
                 .context("failed to create stream")?;
             let (trailers_tx, trailers_rx) = instance
                 .future(|| Ok(None), &mut view)
@@ -1107,7 +1107,7 @@ where
         store.with(|mut view| {
             let instance = view.instance();
             let (contents_tx, contents_rx) = instance
-                .stream::<_, _, Vec<_>, _, _>(&mut view)
+                .stream::<_, _, Vec<_>>(&mut view)
                 .context("failed to create stream")?;
             let (trailers_tx, trailers_rx) = instance
                 .future(|| Ok(None), &mut view)

crates/wasi/src/p3/cli/host.rs

@@ -171,7 +171,7 @@ where
         store.with(|mut view| {
             let instance = view.instance();
             let (tx, rx) = instance
-                .stream::<_, _, Vec<_>, _, _>(&mut view)
+                .stream::<_, _, Vec<_>>(&mut view)
                 .context("failed to create stream")?;
             let stdin = view.get().cli().stdin.reader();
             view.spawn(InputTask { input: stdin, tx });

crates/wasi/src/p3/filesystem/host.rs

@@ -61,7 +61,7 @@ where
         store.with(|mut view| {
             let instance = view.instance();
             let (data_tx, data_rx) = instance
-                .stream::<_, _, Vec<_>, _, _>(&mut view)
+                .stream::<_, _, Vec<_>>(&mut view)
                 .context("failed to create stream")?;
             let (res_tx, res_rx) = instance
                 .future(|| unreachable!(), &mut view)
@@ -150,7 +150,7 @@ where
     ) -> wasmtime::Result<Result<(), ErrorCode>> {
         let mut buf = Vec::with_capacity(8096);
         let (fd, fut) = store.with(|mut view| {
-            let data = data.into_reader::<Vec<u8>, _, _>(&mut view);
+            let data = data.into_reader::<Vec<u8>>(&mut view);
             let fut = data.read(buf);
             let fd = get_descriptor(view.get().table(), &fd)?.clone();
             anyhow::Ok((fd.clone(), fut))
@@ -198,7 +198,7 @@ where
     ) -> wasmtime::Result<Result<(), ErrorCode>> {
         let mut buf = Vec::with_capacity(8096);
         let (fd, fut) = store.with(|mut view| {
-            let data = data.into_reader::<Vec<u8>, _, _>(&mut view);
+            let data = data.into_reader::<Vec<u8>>(&mut view);
             let fut = data.read(buf);
             let fd = get_descriptor(view.get().table(), &fd)?.clone();
             anyhow::Ok((fd, fut))
@@ -318,7 +318,7 @@ where
         store.with(|mut view| {
             let instance = view.instance();
             let (data_tx, data_rx) = instance
-                .stream::<_, _, Vec<_>, _, _>(&mut view)
+                .stream::<_, _, Vec<_>>(&mut view)
                 .context("failed to create stream")?;
             let (res_tx, res_rx) = instance
                 .future(|| unreachable!(), &mut view)

crates/wasi/src/p3/sockets/host/types/tcp.rs

@@ -289,7 +289,7 @@ where
             };
             let instance = view.instance();
             let (tx, rx) = instance
-                .stream::<_, _, Vec<_>, _, _>(&mut view)
+                .stream::<_, _, Vec<_>>(&mut view)
                 .context("failed to create stream")?;
             let &TcpSocket {
                 listen_backlog_size,
@@ -379,7 +379,7 @@ where
     ) -> wasmtime::Result<Result<(), ErrorCode>> {
         let mut buf = Vec::with_capacity(8096);
         let (stream, fut) = match store.with(|mut view| {
-            let data = data.into_reader::<Vec<u8>, _, _>(&mut view);
+            let data = data.into_reader::<Vec<u8>>(&mut view);
             let fut = data.read(buf);
             let mut binding = view.get();
             let sock = get_socket(binding.table(), &socket)?;
@@ -440,7 +440,7 @@ where
         store.with(|mut view| {
             let instance = view.instance();
             let (data_tx, data_rx) = instance
-                .stream::<_, _, Vec<_>, _, _>(&mut view)
+                .stream::<_, _, Vec<_>>(&mut view)
                 .context("failed to create stream")?;
             let (res_tx, res_rx) = instance
                 .future(|| unreachable!(), &mut view)

crates/wasmtime/src/runtime/component/concurrent/futures_and_streams.rs

@@ -605,14 +605,14 @@ impl<T> HostFuture<T> {
     }
 
     /// Convert this object into a [`FutureReader`].
-    pub fn into_reader<U: 'static, S: AsContextMut<Data = U>>(self, mut store: S) -> FutureReader<T>
+    pub fn into_reader(self, mut store: impl AsContextMut) -> FutureReader<T>
     where
         T: func::Lower + func::Lift + Send + Sync + 'static,
     {
         FutureReader {
             instance: self.instance,
             rep: self.rep,
-            tx: Some(self.instance.start_read_event_loop::<_, _, U>(
+            tx: Some(self.instance.start_read_event_loop(
                 store.as_context_mut(),
                 self.rep,
                 TransmitKind::Future,
@@ -984,18 +984,15 @@ impl<T> HostStream<T> {
     }
 
     /// Convert this object into a [`StreamReader`].
-    pub fn into_reader<B, U: 'static, S: AsContextMut<Data = U>>(
-        self,
-        mut store: S,
-    ) -> StreamReader<B>
+    pub fn into_reader<B>(self, mut store: impl AsContextMut) -> StreamReader<B>
     where
         T: func::Lower + func::Lift + Send + 'static,
         B: ReadBuffer<T>,
     {
         StreamReader {
             instance: self.instance,
             rep: self.rep,
-            tx: Some(self.instance.start_read_event_loop::<_, _, U>(
+            tx: Some(self.instance.start_read_event_loop(
                 store.as_context_mut(),
                 self.rep,
                 TransmitKind::Stream,
@@ -1233,7 +1230,7 @@ impl ErrorContext {
     }
 
     /// Attempt to convert the specified [`Val`] to a `ErrorContext`.
-    pub fn from_val<U, S: AsContextMut<Data = U>>(_: S, value: &Val) -> Result<Self> {
+    pub fn from_val(_: impl AsContextMut, value: &Val) -> Result<Self> {
         let Val::ErrorContext(ErrorContextAny(rep)) = value else {
             bail!("expected `error-context`; got `{}`", value.desc());
         };
@@ -1516,22 +1513,18 @@ impl Instance {
     /// If there's no plausible default value, and you're sure
     /// `FutureWriter::write` will be called, you can consider passing `||
     /// unreachable!()` as the `default` parameter.
-    pub fn future<
-        T: func::Lower + func::Lift + Send + Sync + 'static,
-        U: 'static,
-        S: AsContextMut<Data = U>,
-    >(
+    pub fn future<T: func::Lower + func::Lift + Send + Sync + 'static>(
         self,
         default: fn() -> T,
-        mut store: S,
+        mut store: impl AsContextMut,
     ) -> Result<(FutureWriter<T>, FutureReader<T>)> {
         let mut store = store.as_context_mut();
         let (write, read) = self.concurrent_state_mut(store.0).new_transmit()?;
 
         Ok((
             FutureWriter::new(
                 default,
-                Some(self.start_write_event_loop::<_, _, U>(
+                Some(self.start_write_event_loop(
                     store.as_context_mut(),
                     write.rep(),
                     TransmitKind::Future,
@@ -1540,7 +1533,7 @@ impl Instance {
             ),
             FutureReader::new(
                 read.rep(),
-                Some(self.start_read_event_loop::<_, _, U>(
+                Some(self.start_read_event_loop(
                     store.as_context_mut(),
                     read.rep(),
                     TransmitKind::Future,
@@ -1556,18 +1549,16 @@ impl Instance {
         T: func::Lower + func::Lift + Send + 'static,
         W: WriteBuffer<T>,
         R: ReadBuffer<T>,
-        U: 'static,
-        S: AsContextMut<Data = U>,
     >(
         self,
-        mut store: S,
+        mut store: impl AsContextMut,
     ) -> Result<(StreamWriter<W>, StreamReader<R>)> {
         let mut store = store.as_context_mut();
         let (write, read) = self.concurrent_state_mut(store.0).new_transmit()?;
 
         Ok((
             StreamWriter::new(
-                Some(self.start_write_event_loop::<_, _, U>(
+                Some(self.start_write_event_loop(
                     store.as_context_mut(),
                     write.rep(),
                     TransmitKind::Stream,
@@ -1576,7 +1567,7 @@ impl Instance {
             ),
             StreamReader::new(
                 read.rep(),
-                Some(self.start_read_event_loop::<_, _, U>(
+                Some(self.start_read_event_loop(
                     store.as_context_mut(),
                     read.rep(),
                     TransmitKind::Stream,
@@ -1598,7 +1589,7 @@ impl Instance {
     fn start_write_event_loop<
         T: func::Lower + func::Lift + Send + 'static,
         B: WriteBuffer<T>,
-        U: 'static,
+        U,
     >(
         self,
         mut store: StoreContextMut<U>,
@@ -1668,11 +1659,7 @@ impl Instance {
 
     /// Same as `Self::start_write_event_loop`, but for the read end of a stream
     /// or future.
-    fn start_read_event_loop<
-        T: func::Lower + func::Lift + Send + 'static,
-        B: ReadBuffer<T>,
-        U: 'static,
-    >(
+    fn start_read_event_loop<T: func::Lower + func::Lift + Send + 'static, B: ReadBuffer<T>, U>(
         self,
         mut store: StoreContextMut<U>,
         rep: u32,
@@ -1748,7 +1735,7 @@ impl Instance {
     /// * `post_write` - Whether the transmit should be dropped after write, possibly with an error context
     /// * `tx` - Oneshot channel to notify when operation completes (or drop on error)
     /// * `kind` - whether this is a stream or a future
-    fn host_write<T: func::Lower + Send + 'static, B: WriteBuffer<T>, U: 'static>(
+    fn host_write<T: func::Lower + Send + 'static, B: WriteBuffer<T>, U>(
         self,
         mut store: StoreContextMut<U>,
         transmit_rep: u32,
@@ -1871,7 +1858,7 @@ impl Instance {
     /// * `buffer` - Buffer to receive values
     /// * `tx` - Oneshot channel to notify when operation completes (or drop on error)
     /// * `kind` - whether this is a stream or a future
-    fn host_read<T: func::Lift + Send + 'static, B: ReadBuffer<T>, U: 'static>(
+    fn host_read<T: func::Lift + Send + 'static, B: ReadBuffer<T>, U>(
         self,
         mut store: StoreContextMut<U>,
         rep: u32,
@@ -2792,7 +2779,7 @@ impl Instance {
     ///
     /// SAFETY: `memory` and `realloc` must be valid pointers to their
     /// respective guest entities.
-    pub(super) unsafe fn error_context_debug_message<T: 'static>(
+    pub(super) unsafe fn error_context_debug_message<T>(
         self,
         store: StoreContextMut<T>,
         memory: *mut VMMemoryDefinition,