Massage wasmtime-wasi to use vendored primitives

This commit adjust the wasmtime 36.0.0 state of the `wasmtime-wasi`
crate to use the vendored primitives in the prior commit. This is much
more involved than just a cherry-pick because the internals of
`wasmtime-wasi` have greatly changed since the 36.0.0 release, namely:

* WASIp3 support was added and shared code between p2/p3 was refactored
  to its own module.
* The `cap-std` dependency was largely removed which vendored some
  fringe platform-specific code from that and surrounding crates.

These major changes aren't present on the 36.0.0 branch, and
additionally the public types of `wasmtime-wasi` contain more `cap_std`
types than before. To handle all of this the commit here leaves the
public type definitions as-is but helpers internally all switch to using
the previously-vendored primitives. This involved vendoring more code
from the `main` branch and is a bit invasive, but this is all necessary
to sever dependencies with the `cap-std` crates.

Author: alexcrichton

Cargo.lock

@@ -60,11 +60,14 @@ winx = "0.36.0"
 workspace = true
 features = [
   "Wdk_Storage_FileSystem",
+  "Wdk_Foundation",
   "Win32_Foundation",
   "Win32_Storage_FileSystem",
   "Win32_System_IO",
   "Win32_System_Ioctl",
   "Win32_System_Performance",
+  "Win32_System_WindowsProgramming",
+  "Win32_System_SystemServices",
 ]
 
 [features]

crates/wasi/Cargo.toml

@@ -6,7 +6,6 @@ use crate::sockets::{SocketAddrCheck, SocketAddrUse, WasiSocketsCtx};
 use crate::{DirPerms, FilePerms, OpenMode};
 use anyhow::Result;
 use cap_rand::RngCore;
-use cap_std::ambient_authority;
 use std::future::Future;
 use std::mem;
 use std::net::SocketAddr;

crates/wasi/src/ctx.rs

@@ -30,3 +30,5 @@ bitflags::bitflags! {
         const MUTATE = 0b10;
     }
 }
+
+pub(crate) mod primitives;

crates/wasi/src/filesystem.rs

@@ -115,6 +115,7 @@ impl FileTypeExt for FileType {
 /// `std`. Use `cap_fs_ext::FileTypeExt` instead of calling this directly.
 #[cfg(windows)]
 #[doc(hidden)]
+#[allow(unused)]
 pub trait _WindowsFileTypeExt {
     fn is_block_device(&self) -> bool;
     fn is_char_device(&self) -> bool;

crates/wasi/src/filesystem/primitives/file_type.rs

@@ -5,7 +5,7 @@ use super::helpers as h;
 use super::sys_common::io::tmpdir;
 use super::sys_common::symlink_junction;
 use crate::filesystem::primitives as p;
-use rand::Rng;
+use cap_rand::RngCore;
 use std::fs::File;
 use std::io::prelude::*;
 use std::io::{ErrorKind, SeekFrom};
@@ -964,7 +964,7 @@ fn _assert_send_sync() {
 #[test]
 fn binary_file() {
     let mut bytes = [0; 1024];
-    rand::rng().fill_bytes(&mut bytes);
+    cap_rand::thread_rng(cap_std::ambient_authority()).fill_bytes(&mut bytes);
 
     let tmpdir = tmpdir();
 
@@ -979,7 +979,7 @@ fn binary_file() {
 #[test]
 fn write_then_read() {
     let mut bytes = [0; 1024];
-    rand::rng().fill_bytes(&mut bytes);
+    cap_rand::thread_rng(cap_std::ambient_authority()).fill_bytes(&mut bytes);
 
     let tmpdir = tmpdir();
 

crates/wasi/src/filesystem/primitives/tests/fs.rs

@@ -4,6 +4,7 @@ use crate::runtime::{AbortOnDropJoinHandle, spawn_blocking};
 use crate::{DirPerms, FilePerms, OpenMode, TrappableError};
 use anyhow::anyhow;
 use bytes::{Bytes, BytesMut};
+use io_lifetimes::AsFilelike;
 use std::io;
 use std::mem;
 use std::sync::Arc;
@@ -113,30 +114,32 @@ impl File {
     /// - [Implement opt-in for enabling WASI to block the current thread](https://github.com/bytecodealliance/wasmtime/pull/8190)
     pub(crate) async fn run_blocking<F, R>(&self, body: F) -> R
     where
-        F: FnOnce(&cap_std::fs::File) -> R + Send + 'static,
+        F: FnOnce(&std::fs::File) -> R + Send + 'static,
         R: Send + 'static,
     {
-        match self.as_blocking_file() {
-            Some(file) => body(file),
-            None => self.spawn_blocking(body).await,
+        if let Some(file) = self.as_blocking_file() {
+            return body(&file);
         }
+        self.spawn_blocking(body).await
     }
 
     pub(crate) fn spawn_blocking<F, R>(&self, body: F) -> AbortOnDropJoinHandle<R>
     where
-        F: FnOnce(&cap_std::fs::File) -> R + Send + 'static,
+        F: FnOnce(&std::fs::File) -> R + Send + 'static,
         R: Send + 'static,
     {
         let f = self.file.clone();
-        spawn_blocking(move || body(&f))
+        spawn_blocking(move || body(&f.as_filelike_view()))
     }
 
     /// Returns `Some` when the current thread is allowed to block in filesystem
     /// operations, and otherwise returns `None` to indicate that
     /// `spawn_blocking` must be used.
-    pub(crate) fn as_blocking_file(&self) -> Option<&cap_std::fs::File> {
+    pub(crate) fn as_blocking_file(
+        &self,
+    ) -> Option<io_lifetimes::views::FilelikeView<'_, std::fs::File>> {
         if self.allow_blocking_current_thread {
-            Some(&self.file)
+            Some(self.file.as_filelike_view())
         } else {
             None
         }
@@ -203,14 +206,14 @@ impl Dir {
     /// - [Implement opt-in for enabling WASI to block the current thread](https://github.com/bytecodealliance/wasmtime/pull/8190)
     pub(crate) async fn run_blocking<F, R>(&self, body: F) -> R
     where
-        F: FnOnce(&cap_std::fs::Dir) -> R + Send + 'static,
+        F: FnOnce(&std::fs::File) -> R + Send + 'static,
         R: Send + 'static,
     {
         if self.allow_blocking_current_thread {
-            body(&self.dir)
+            body(&self.dir.as_filelike_view())
         } else {
             let d = self.dir.clone();
-            spawn_blocking(move || body(&d)).await
+            spawn_blocking(move || body(&d.as_filelike_view())).await
         }
     }
 }
@@ -236,7 +239,7 @@ impl FileInputStream {
         }
     }
 
-    fn blocking_read(file: &cap_std::fs::File, offset: u64, size: usize) -> ReadState {
+    fn blocking_read(file: &std::fs::File, offset: u64, size: usize) -> ReadState {
         use system_interface::fs::FileIoExt;
 
         let mut buf = BytesMut::zeroed(size.min(crate::MAX_READ_SIZE_ALLOC));
@@ -392,7 +395,7 @@ impl FileOutputStream {
     }
 
     fn blocking_write(
-        file: &cap_std::fs::File,
+        file: &std::fs::File,
         mut buf: Bytes,
         mode: FileOutputMode,
     ) -> io::Result<usize> {