Remove duplication in wasi-common for snapshot_0 (#2444)

This commit deletes the old `snapshot_0` implementation of wasi-common,
along with the `wig` crate that was used to generate bindings for it.
This then reimplements `snapshot_0` in terms of
`wasi_snapshot_preview1`. There were very few changes between the two
snapshots:

* The `nlink` field of `FileStat` was increased from 32 to 64 bits.
* The `set` field of `whence` was reordered.
* Clock subscriptions in polling dropped their redundant userdata field.

This makes all of the syscalls relatively straightforward to simply
delegate to the next snapshot's implementation. Some trickery happens to
avoid extra cost when dealing with iovecs, but since the memory layout
of iovecs remained the same this should still work.

Now that `snapshot_0` is using wiggle we simply have a trait to
implement, and that's implemented for the same `WasiCtx` that has the
`wasi_snapshot_preview1` trait implemented for it as well. While this
theoretically means that you could share the file descriptor table
between the two snapshots that's not supported in the generated bindings
just yet. A separate `WasiCtx` will be created for each WASI module.

crates/wasi-common/src/snapshots/wasi_snapshot_preview1.rs

@@ -680,6 +680,69 @@ impl<'a> WasiSnapshotPreview1 for WasiCtx {
             subscriptions.push(sub);
         }
 
+        let events = self.poll_oneoff_impl(&subscriptions)?;
+        let nevents = events.len().try_into()?;
+
+        let out_events = out.as_array(nevents);
+        for (event, event_ptr) in events.into_iter().zip(out_events.iter()) {
+            let event_ptr = event_ptr?;
+            event_ptr.write(event)?;
+        }
+
+        trace!(nevents = nevents);
+
+        Ok(nevents)
+    }
+
+    fn proc_exit(&self, _rval: types::Exitcode) -> std::result::Result<(), ()> {
+        // proc_exit is special in that it's expected to unwind the stack, which
+        // typically requires runtime-specific logic.
+        unimplemented!("runtimes are expected to override this implementation")
+    }
+
+    fn proc_raise(&self, _sig: types::Signal) -> Result<()> {
+        unimplemented!("proc_raise")
+    }
+
+    fn sched_yield(&self) -> Result<()> {
+        std::thread::yield_now();
+        Ok(())
+    }
+
+    fn random_get(&self, buf: &GuestPtr<u8>, buf_len: types::Size) -> Result<()> {
+        let mut slice = buf.as_array(buf_len).as_slice_mut()?;
+        getrandom::getrandom(&mut *slice)?;
+        Ok(())
+    }
+
+    fn sock_recv(
+        &self,
+        _fd: types::Fd,
+        _ri_data: &types::IovecArray<'_>,
+        _ri_flags: types::Riflags,
+    ) -> Result<(types::Size, types::Roflags)> {
+        unimplemented!("sock_recv")
+    }
+
+    fn sock_send(
+        &self,
+        _fd: types::Fd,
+        _si_data: &types::CiovecArray<'_>,
+        _si_flags: types::Siflags,
+    ) -> Result<types::Size> {
+        unimplemented!("sock_send")
+    }
+
+    fn sock_shutdown(&self, _fd: types::Fd, _how: types::Sdflags) -> Result<()> {
+        unimplemented!("sock_shutdown")
+    }
+}
+
+impl WasiCtx {
+    pub(crate) fn poll_oneoff_impl(
+        &self,
+        subscriptions: &[types::Subscription],
+    ) -> Result<Vec<types::Event>> {
         let mut events = Vec::new();
         let mut timeout: Option<sched::ClockEventData> = None;
         let mut fd_events = Vec::new();
@@ -691,7 +754,7 @@ impl<'a> WasiSnapshotPreview1 for WasiCtx {
         }
 
         for subscription in subscriptions {
-            match subscription.u {
+            match &subscription.u {
                 types::SubscriptionU::Clock(clock) => {
                     let delay = clock::to_relative_ns_delay(&clock)?;
                     debug!(
@@ -771,59 +834,6 @@ impl<'a> WasiSnapshotPreview1 for WasiCtx {
         // if no events have been passed. Such situation may occur if all provided
         // events have been filtered out as errors in the code above.
         poll::oneoff(timeout, fd_events, &mut events)?;
-        let nevents = events.len().try_into()?;
-
-        let out_events = out.as_array(nevents);
-        for (event, event_ptr) in events.into_iter().zip(out_events.iter()) {
-            let event_ptr = event_ptr?;
-            event_ptr.write(event)?;
-        }
-
-        trace!(nevents = nevents);
-
-        Ok(nevents)
-    }
-
-    fn proc_exit(&self, _rval: types::Exitcode) -> std::result::Result<(), ()> {
-        // proc_exit is special in that it's expected to unwind the stack, which
-        // typically requires runtime-specific logic.
-        unimplemented!("runtimes are expected to override this implementation")
-    }
-
-    fn proc_raise(&self, _sig: types::Signal) -> Result<()> {
-        unimplemented!("proc_raise")
-    }
-
-    fn sched_yield(&self) -> Result<()> {
-        std::thread::yield_now();
-        Ok(())
-    }
-
-    fn random_get(&self, buf: &GuestPtr<u8>, buf_len: types::Size) -> Result<()> {
-        let mut slice = buf.as_array(buf_len).as_slice_mut()?;
-        getrandom::getrandom(&mut *slice)?;
-        Ok(())
-    }
-
-    fn sock_recv(
-        &self,
-        _fd: types::Fd,
-        _ri_data: &types::IovecArray<'_>,
-        _ri_flags: types::Riflags,
-    ) -> Result<(types::Size, types::Roflags)> {
-        unimplemented!("sock_recv")
-    }
-
-    fn sock_send(
-        &self,
-        _fd: types::Fd,
-        _si_data: &types::CiovecArray<'_>,
-        _si_flags: types::Siflags,
-    ) -> Result<types::Size> {
-        unimplemented!("sock_send")
-    }
-
-    fn sock_shutdown(&self, _fd: types::Fd, _how: types::Sdflags) -> Result<()> {
-        unimplemented!("sock_shutdown")
+        Ok(events)
     }
 }