ci: unfreeze wasm tests from rustc 1.88.0

.github/workflows/ci.yml

@@ -988,10 +988,10 @@ jobs:
             features: "macros sync time rt"
     steps:
       - uses: actions/checkout@v5
-      - name: Install Rust 1.88.0
+      - name: Install Rust ${{ env.rust_stable }}
         uses: dtolnay/rust-toolchain@stable
         with:
-          toolchain: 1.88.0
+          toolchain: ${{ env.rust_stable }}
       - name: Install wasm-pack
         uses: taiki-e/install-action@wasm-pack
 
@@ -1011,10 +1011,10 @@ jobs:
           - wasm32-wasip1-threads
     steps:
       - uses: actions/checkout@v4
-      - name: Install Rust 1.88.0
+      - name: Install Rust ${{ env.rust_stable }}
         uses: dtolnay/rust-toolchain@stable
         with:
-          toolchain: 1.88.0
+          toolchain: ${{ env.rust_stable }}
           targets: ${{ matrix.target }}
 
       # Install dependencies
@@ -1025,11 +1025,14 @@ jobs:
 
       - uses: Swatinem/rust-cache@v2
       - name: WASI test tokio full
-        run: cargo test -p tokio --target ${{ matrix.target }} --features full
+        run: cargo test -p tokio --target ${{ matrix.target }} --features "sync,macros,io-util,rt,time"
         env:
           CARGO_TARGET_WASM32_WASIP1_RUNNER: "wasmtime run --"
           CARGO_TARGET_WASM32_WASIP1_THREADS_RUNNER: "wasmtime run -W bulk-memory=y -W threads=y -S threads=y --"
           RUSTFLAGS: --cfg tokio_unstable -Dwarnings -C target-feature=+atomics,+bulk-memory -C link-args=--max-memory=67108864
+          # in order to run doctests for unstable features, we must also pass
+          # the unstable cfg to RustDoc
+          RUSTDOCFLAGS: --cfg tokio_unstable
 
       - name: WASI test tokio-util full
         run: cargo test -p tokio-util --target ${{ matrix.target }} --features full

tokio-stream/src/empty.rs

@@ -26,12 +26,12 @@ unsafe impl<T> Sync for Empty<T> {}
 /// ```
 /// use tokio_stream::{self as stream, StreamExt};
 ///
-/// #[tokio::main]
-/// async fn main() {
-///     let mut none = stream::empty::<i32>();
+/// # #[tokio::main(flavor = "current_thread")]
+/// # async fn main() {
+/// let mut none = stream::empty::<i32>();
 ///
-///     assert_eq!(None, none.next().await);
-/// }
+/// assert_eq!(None, none.next().await);
+/// # }
 /// ```
 pub const fn empty<T>() -> Empty<T> {
     Empty(PhantomData)

tokio-stream/src/lib.rs

@@ -34,14 +34,14 @@
 //! ```rust
 //! use tokio_stream::{self as stream, StreamExt};
 //!
-//! #[tokio::main]
-//! async fn main() {
-//!     let mut stream = stream::iter(vec![0, 1, 2]);
+//! # #[tokio::main(flavor = "current_thread")]
+//! # async fn main() {
+//! let mut stream = stream::iter(vec![0, 1, 2]);
 //!
-//!     while let Some(value) = stream.next().await {
-//!         println!("Got {}", value);
-//!     }
+//! while let Some(value) = stream.next().await {
+//!     println!("Got {}", value);
 //! }
+//! # }
 //! ```
 //!
 //! # Returning a Stream from a function

tokio-stream/src/once.rs

@@ -22,16 +22,16 @@ impl<I> Unpin for Once<I> {}
 /// ```
 /// use tokio_stream::{self as stream, StreamExt};
 ///
-/// #[tokio::main]
-/// async fn main() {
-///     // one is the loneliest number
-///     let mut one = stream::once(1);
+/// # #[tokio::main(flavor = "current_thread")]
+/// # async fn main() {
+/// // one is the loneliest number
+/// let mut one = stream::once(1);
 ///
-///     assert_eq!(Some(1), one.next().await);
+/// assert_eq!(Some(1), one.next().await);
 ///
-///     // just one, that's all we get
-///     assert_eq!(None, one.next().await);
-/// }
+/// // just one, that's all we get
+/// assert_eq!(None, one.next().await);
+/// # }
 /// ```
 pub fn once<T>(value: T) -> Once<T> {
     Once {

tokio-stream/src/stream_close.rs

@@ -17,20 +17,20 @@ pin_project! {
     /// ```
     /// use tokio_stream::{StreamExt, StreamMap, StreamNotifyClose};
     ///
-    /// #[tokio::main]
-    /// async fn main() {
-    ///     let mut map = StreamMap::new();
-    ///     let stream = StreamNotifyClose::new(tokio_stream::iter(vec![0, 1]));
-    ///     let stream2 = StreamNotifyClose::new(tokio_stream::iter(vec![0, 1]));
-    ///     map.insert(0, stream);
-    ///     map.insert(1, stream2);
-    ///     while let Some((key, val)) = map.next().await {
-    ///         match val {
-    ///             Some(val) => println!("got {val:?} from stream {key:?}"),
-    ///             None => println!("stream {key:?} closed"),
-    ///         }
+    /// # #[tokio::main(flavor = "current_thread")]
+    /// # async fn main() {
+    /// let mut map = StreamMap::new();
+    /// let stream = StreamNotifyClose::new(tokio_stream::iter(vec![0, 1]));
+    /// let stream2 = StreamNotifyClose::new(tokio_stream::iter(vec![0, 1]));
+    /// map.insert(0, stream);
+    /// map.insert(1, stream2);
+    /// while let Some((key, val)) = map.next().await {
+    ///     match val {
+    ///         Some(val) => println!("got {val:?} from stream {key:?}"),
+    ///         None => println!("stream {key:?} closed"),
     ///     }
     /// }
+    /// # }
     /// ```
     #[must_use = "streams do nothing unless polled"]
     pub struct StreamNotifyClose<S> {