Start to port Wasmtime to the new wasi-io API with resources.

Cargo.toml

@@ -213,7 +213,7 @@ io-extras = "0.18.0"
 rustix = "0.38.8"
 is-terminal = "0.4.0"
 # wit-bindgen:
-wit-bindgen = { version = "0.11.0", default-features = false }
+wit-bindgen = { version = "0.12.0", default-features = false }
 
 # wasm-tools family:
 wasmparser = "0.113.2"

crates/test-programs/command-tests/src/bin/stream_pollable_lifetimes.rs

@@ -1,24 +1,24 @@
 use command_tests::wasi::cli::environment;
 use command_tests::wasi::cli::stdin;
+use command_tests::wasi::io::poll;
 use command_tests::wasi::io::streams;
-use command_tests::wasi::poll::poll;
 
 fn main() {
     let args = environment::get_arguments();
 
     if args == &["correct"] {
         let stdin: streams::InputStream = stdin::get_stdin();
-        let stdin_pollable = streams::subscribe_to_input_stream(stdin);
-        let ready = poll::poll_oneoff(&[stdin_pollable]);
-        assert_eq!(ready, &[true]);
-        poll::drop_pollable(stdin_pollable);
-        streams::drop_input_stream(stdin);
+        let stdin_pollable = stdin.subscribe();
+        let ready = poll::poll_list(&[&stdin_pollable]);
+        assert_eq!(ready, &[0]);
+        drop(stdin_pollable);
+        drop(stdin);
     } else if args == &["trap"] {
         let stdin: streams::InputStream = stdin::get_stdin();
-        let stdin_pollable = streams::subscribe_to_input_stream(stdin);
-        let ready = poll::poll_oneoff(&[stdin_pollable]);
-        assert_eq!(ready, &[true]);
-        streams::drop_input_stream(stdin);
+        let stdin_pollable = stdin.subscribe();
+        let ready = poll::poll_list(&[&stdin_pollable]);
+        assert_eq!(ready, &[0]);
+        drop(stdin);
         unreachable!(
             "execution should have trapped in line above when stream dropped before pollable"
         );

crates/test-programs/reactor-tests/src/lib.rs

@@ -7,21 +7,10 @@ wit_bindgen::generate!({
 });
 
 struct T;
-use wasi::io::streams;
-use wasi::poll::poll;
+use wasi::io::poll;
 
 static mut STATE: Vec<String> = Vec::new();
 
-struct DropPollable {
-    pollable: poll::Pollable,
-}
-
-impl Drop for DropPollable {
-    fn drop(&mut self) {
-        poll::drop_pollable(self.pollable);
-    }
-}
-
 impl Guest for T {
     fn add_strings(ss: Vec<String>) -> u32 {
         for s in ss {
@@ -40,34 +29,32 @@ impl Guest for T {
     }
 
     fn write_strings_to(o: OutputStream) -> Result<(), ()> {
-        let sub = DropPollable {
-            pollable: streams::subscribe_to_output_stream(o),
-        };
+        let pollable = o.subscribe();
         unsafe {
             for s in STATE.iter() {
                 let mut out = s.as_bytes();
                 while !out.is_empty() {
-                    poll::poll_oneoff(&[sub.pollable]);
-                    let n = match streams::check_write(o) {
+                    poll::poll_list(&[&pollable]);
+                    let n = match o.check_write() {
                         Ok(n) => n,
                         Err(_) => return Err(()),
                     };
 
                     let len = (n as usize).min(out.len());
-                    match streams::write(o, &out[..len]) {
+                    match o.write(&out[..len]) {
                         Ok(_) => out = &out[len..],
                         Err(_) => return Err(()),
                     }
                 }
             }
 
-            match streams::flush(o) {
+            match o.flush() {
                 Ok(_) => {}
                 Err(_) => return Err(()),
             }
 
-            poll::poll_oneoff(&[sub.pollable]);
-            match streams::check_write(o) {
+            poll::poll_list(&[&pollable]);
+            match o.check_write() {
                 Ok(_) => {}
                 Err(_) => return Err(()),
             }