wasmtime 25.0.1 → 25.0.2

data/ext/cargo-vendor/tokio-1.39.3/src/io/util/empty.rs

@@ -1,164 +0,0 @@
-use crate::io::util::poll_proceed_and_make_progress;
-use crate::io::{AsyncBufRead, AsyncRead, AsyncSeek, AsyncWrite, ReadBuf};
-
-use std::fmt;
-use std::io::{self, SeekFrom};
-use std::pin::Pin;
-use std::task::{Context, Poll};
-
-cfg_io_util! {
-    /// `Empty` ignores any data written via [`AsyncWrite`], and will always be empty
-    /// (returning zero bytes) when read via [`AsyncRead`].
-    ///
-    /// This struct is generally created by calling [`empty`]. Please see
-    /// the documentation of [`empty()`][`empty`] for more details.
-    ///
-    /// This is an asynchronous version of [`std::io::empty`][std].
-    ///
-    /// [`empty`]: fn@empty
-    /// [std]: std::io::empty
-    pub struct Empty {
-        _p: (),
-    }
-
-    /// Creates a value that is always at EOF for reads, and ignores all data written.
-    ///
-    /// All writes on the returned instance will return `Poll::Ready(Ok(buf.len()))`
-    /// and the contents of the buffer will not be inspected.
-    ///
-    /// All reads from the returned instance will return `Poll::Ready(Ok(0))`.
-    ///
-    /// This is an asynchronous version of [`std::io::empty`][std].
-    ///
-    /// [std]: std::io::empty
-    ///
-    /// # Examples
-    ///
-    /// A slightly sad example of not reading anything into a buffer:
-    ///
-    /// ```
-    /// use tokio::io::{self, AsyncReadExt};
-    ///
-    /// #[tokio::main]
-    /// async fn main() {
-    ///     let mut buffer = String::new();
-    ///     io::empty().read_to_string(&mut buffer).await.unwrap();
-    ///     assert!(buffer.is_empty());
-    /// }
-    /// ```
-    ///
-    /// A convoluted way of getting the length of a buffer:
-    ///
-    /// ```
-    /// use tokio::io::{self, AsyncWriteExt};
-    ///
-    /// #[tokio::main]
-    /// async fn main() {
-    ///     let buffer = vec![1, 2, 3, 5, 8];
-    ///     let num_bytes = io::empty().write(&buffer).await.unwrap();
-    ///     assert_eq!(num_bytes, 5);
-    /// }
-    /// ```
-    pub fn empty() -> Empty {
-        Empty { _p: () }
-    }
-}
-
-impl AsyncRead for Empty {
-    #[inline]
-    fn poll_read(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        _: &mut ReadBuf<'_>,
-    ) -> Poll<io::Result<()>> {
-        ready!(crate::trace::trace_leaf(cx));
-        ready!(poll_proceed_and_make_progress(cx));
-        Poll::Ready(Ok(()))
-    }
-}
-
-impl AsyncBufRead for Empty {
-    #[inline]
-    fn poll_fill_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<&[u8]>> {
-        ready!(crate::trace::trace_leaf(cx));
-        ready!(poll_proceed_and_make_progress(cx));
-        Poll::Ready(Ok(&[]))
-    }
-
-    #[inline]
-    fn consume(self: Pin<&mut Self>, _: usize) {}
-}
-
-impl AsyncWrite for Empty {
-    #[inline]
-    fn poll_write(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &[u8],
-    ) -> Poll<io::Result<usize>> {
-        ready!(crate::trace::trace_leaf(cx));
-        ready!(poll_proceed_and_make_progress(cx));
-        Poll::Ready(Ok(buf.len()))
-    }
-
-    #[inline]
-    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
-        ready!(crate::trace::trace_leaf(cx));
-        ready!(poll_proceed_and_make_progress(cx));
-        Poll::Ready(Ok(()))
-    }
-
-    #[inline]
-    fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
-        ready!(crate::trace::trace_leaf(cx));
-        ready!(poll_proceed_and_make_progress(cx));
-        Poll::Ready(Ok(()))
-    }
-
-    #[inline]
-    fn is_write_vectored(&self) -> bool {
-        true
-    }
-
-    #[inline]
-    fn poll_write_vectored(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        bufs: &[io::IoSlice<'_>],
-    ) -> Poll<Result<usize, io::Error>> {
-        ready!(crate::trace::trace_leaf(cx));
-        ready!(poll_proceed_and_make_progress(cx));
-        let num_bytes = bufs.iter().map(|b| b.len()).sum();
-        Poll::Ready(Ok(num_bytes))
-    }
-}
-
-impl AsyncSeek for Empty {
-    #[inline]
-    fn start_seek(self: Pin<&mut Self>, _position: SeekFrom) -> io::Result<()> {
-        Ok(())
-    }
-
-    #[inline]
-    fn poll_complete(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<u64>> {
-        ready!(crate::trace::trace_leaf(cx));
-        ready!(poll_proceed_and_make_progress(cx));
-        Poll::Ready(Ok(0))
-    }
-}
-
-impl fmt::Debug for Empty {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.pad("Empty { .. }")
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn assert_unpin() {
-        crate::is_unpin::<Empty>();
-    }
-}

data/ext/cargo-vendor/tokio-1.39.3/src/io/util/lines.rs

@@ -1,145 +0,0 @@
-use crate::io::util::read_line::read_line_internal;
-use crate::io::AsyncBufRead;
-
-use pin_project_lite::pin_project;
-use std::io;
-use std::mem;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-
-pin_project! {
-    /// Reads lines from an [`AsyncBufRead`].
-    ///
-    /// A `Lines` can be turned into a `Stream` with [`LinesStream`].
-    ///
-    /// This type is usually created using the [`lines`] method.
-    ///
-    /// [`AsyncBufRead`]: crate::io::AsyncBufRead
-    /// [`LinesStream`]: https://docs.rs/tokio-stream/0.1/tokio_stream/wrappers/struct.LinesStream.html
-    /// [`lines`]: crate::io::AsyncBufReadExt::lines
-    #[derive(Debug)]
-    #[must_use = "streams do nothing unless polled"]
-    #[cfg_attr(docsrs, doc(cfg(feature = "io-util")))]
-    pub struct Lines<R> {
-        #[pin]
-        reader: R,
-        buf: String,
-        bytes: Vec<u8>,
-        read: usize,
-    }
-}
-
-pub(crate) fn lines<R>(reader: R) -> Lines<R>
-where
-    R: AsyncBufRead,
-{
-    Lines {
-        reader,
-        buf: String::new(),
-        bytes: Vec::new(),
-        read: 0,
-    }
-}
-
-impl<R> Lines<R>
-where
-    R: AsyncBufRead + Unpin,
-{
-    /// Returns the next line in the stream.
-    ///
-    /// # Cancel safety
-    ///
-    /// This method is cancellation safe.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use tokio::io::AsyncBufRead;
-    /// use tokio::io::AsyncBufReadExt;
-    ///
-    /// # async fn dox(my_buf_read: impl AsyncBufRead + Unpin) -> std::io::Result<()> {
-    /// let mut lines = my_buf_read.lines();
-    ///
-    /// while let Some(line) = lines.next_line().await? {
-    ///     println!("length = {}", line.len())
-    /// }
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub async fn next_line(&mut self) -> io::Result<Option<String>> {
-        use crate::future::poll_fn;
-
-        poll_fn(|cx| Pin::new(&mut *self).poll_next_line(cx)).await
-    }
-
-    /// Obtains a mutable reference to the underlying reader.
-    pub fn get_mut(&mut self) -> &mut R {
-        &mut self.reader
-    }
-
-    /// Obtains a reference to the underlying reader.
-    pub fn get_ref(&mut self) -> &R {
-        &self.reader
-    }
-
-    /// Unwraps this `Lines<R>`, returning the underlying reader.
-    ///
-    /// Note that any leftover data in the internal buffer is lost.
-    /// Therefore, a following read from the underlying reader may lead to data loss.
-    pub fn into_inner(self) -> R {
-        self.reader
-    }
-}
-
-impl<R> Lines<R>
-where
-    R: AsyncBufRead,
-{
-    /// Polls for the next line in the stream.
-    ///
-    /// This method returns:
-    ///
-    ///  * `Poll::Pending` if the next line is not yet available.
-    ///  * `Poll::Ready(Ok(Some(line)))` if the next line is available.
-    ///  * `Poll::Ready(Ok(None))` if there are no more lines in this stream.
-    ///  * `Poll::Ready(Err(err))` if an IO error occurred while reading the next line.
-    ///
-    /// When the method returns `Poll::Pending`, the `Waker` in the provided
-    /// `Context` is scheduled to receive a wakeup when more bytes become
-    /// available on the underlying IO resource.  Note that on multiple calls to
-    /// `poll_next_line`, only the `Waker` from the `Context` passed to the most
-    /// recent call is scheduled to receive a wakeup.
-    pub fn poll_next_line(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<io::Result<Option<String>>> {
-        let me = self.project();
-
-        let n = ready!(read_line_internal(me.reader, cx, me.buf, me.bytes, me.read))?;
-        debug_assert_eq!(*me.read, 0);
-
-        if n == 0 && me.buf.is_empty() {
-            return Poll::Ready(Ok(None));
-        }
-
-        if me.buf.ends_with('\n') {
-            me.buf.pop();
-
-            if me.buf.ends_with('\r') {
-                me.buf.pop();
-            }
-        }
-
-        Poll::Ready(Ok(Some(mem::take(me.buf))))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn assert_unpin() {
-        crate::is_unpin::<Lines<()>>();
-    }
-}

data/ext/cargo-vendor/tokio-1.39.3/src/io/util/mem.rs

@@ -1,374 +0,0 @@
-//! In-process memory IO types.
-
-use crate::io::{AsyncRead, AsyncWrite, ReadBuf};
-use crate::loom::sync::Mutex;
-
-use bytes::{Buf, BytesMut};
-use std::{
-    pin::Pin,
-    sync::Arc,
-    task::{self, Poll, Waker},
-};
-
-/// A bidirectional pipe to read and write bytes in memory.
-///
-/// A pair of `DuplexStream`s are created together, and they act as a "channel"
-/// that can be used as in-memory IO types. Writing to one of the pairs will
-/// allow that data to be read from the other, and vice versa.
-///
-/// # Closing a `DuplexStream`
-///
-/// If one end of the `DuplexStream` channel is dropped, any pending reads on
-/// the other side will continue to read data until the buffer is drained, then
-/// they will signal EOF by returning 0 bytes. Any writes to the other side,
-/// including pending ones (that are waiting for free space in the buffer) will
-/// return `Err(BrokenPipe)` immediately.
-///
-/// # Example
-///
-/// ```
-/// # async fn ex() -> std::io::Result<()> {
-/// # use tokio::io::{AsyncReadExt, AsyncWriteExt};
-/// let (mut client, mut server) = tokio::io::duplex(64);
-///
-/// client.write_all(b"ping").await?;
-///
-/// let mut buf = [0u8; 4];
-/// server.read_exact(&mut buf).await?;
-/// assert_eq!(&buf, b"ping");
-///
-/// server.write_all(b"pong").await?;
-///
-/// client.read_exact(&mut buf).await?;
-/// assert_eq!(&buf, b"pong");
-/// # Ok(())
-/// # }
-/// ```
-#[derive(Debug)]
-#[cfg_attr(docsrs, doc(cfg(feature = "io-util")))]
-pub struct DuplexStream {
-    read: Arc<Mutex<Pipe>>,
-    write: Arc<Mutex<Pipe>>,
-}
-
-/// A unidirectional IO over a piece of memory.
-///
-/// Data can be written to the pipe, and reading will return that data.
-#[derive(Debug)]
-struct Pipe {
-    /// The buffer storing the bytes written, also read from.
-    ///
-    /// Using a `BytesMut` because it has efficient `Buf` and `BufMut`
-    /// functionality already. Additionally, it can try to copy data in the
-    /// same buffer if there read index has advanced far enough.
-    buffer: BytesMut,
-    /// Determines if the write side has been closed.
-    is_closed: bool,
-    /// The maximum amount of bytes that can be written before returning
-    /// `Poll::Pending`.
-    max_buf_size: usize,
-    /// If the `read` side has been polled and is pending, this is the waker
-    /// for that parked task.
-    read_waker: Option<Waker>,
-    /// If the `write` side has filled the `max_buf_size` and returned
-    /// `Poll::Pending`, this is the waker for that parked task.
-    write_waker: Option<Waker>,
-}
-
-// ===== impl DuplexStream =====
-
-/// Create a new pair of `DuplexStream`s that act like a pair of connected sockets.
-///
-/// The `max_buf_size` argument is the maximum amount of bytes that can be
-/// written to a side before the write returns `Poll::Pending`.
-#[cfg_attr(docsrs, doc(cfg(feature = "io-util")))]
-pub fn duplex(max_buf_size: usize) -> (DuplexStream, DuplexStream) {
-    let one = Arc::new(Mutex::new(Pipe::new(max_buf_size)));
-    let two = Arc::new(Mutex::new(Pipe::new(max_buf_size)));
-
-    (
-        DuplexStream {
-            read: one.clone(),
-            write: two.clone(),
-        },
-        DuplexStream {
-            read: two,
-            write: one,
-        },
-    )
-}
-
-impl AsyncRead for DuplexStream {
-    // Previous rustc required this `self` to be `mut`, even though newer
-    // versions recognize it isn't needed to call `lock()`. So for
-    // compatibility, we include the `mut` and `allow` the lint.
-    //
-    // See https://github.com/rust-lang/rust/issues/73592
-    #[allow(unused_mut)]
-    fn poll_read(
-        mut self: Pin<&mut Self>,
-        cx: &mut task::Context<'_>,
-        buf: &mut ReadBuf<'_>,
-    ) -> Poll<std::io::Result<()>> {
-        Pin::new(&mut *self.read.lock()).poll_read(cx, buf)
-    }
-}
-
-impl AsyncWrite for DuplexStream {
-    #[allow(unused_mut)]
-    fn poll_write(
-        mut self: Pin<&mut Self>,
-        cx: &mut task::Context<'_>,
-        buf: &[u8],
-    ) -> Poll<std::io::Result<usize>> {
-        Pin::new(&mut *self.write.lock()).poll_write(cx, buf)
-    }
-
-    fn poll_write_vectored(
-        self: Pin<&mut Self>,
-        cx: &mut task::Context<'_>,
-        bufs: &[std::io::IoSlice<'_>],
-    ) -> Poll<Result<usize, std::io::Error>> {
-        Pin::new(&mut *self.write.lock()).poll_write_vectored(cx, bufs)
-    }
-
-    fn is_write_vectored(&self) -> bool {
-        true
-    }
-
-    #[allow(unused_mut)]
-    fn poll_flush(
-        mut self: Pin<&mut Self>,
-        cx: &mut task::Context<'_>,
-    ) -> Poll<std::io::Result<()>> {
-        Pin::new(&mut *self.write.lock()).poll_flush(cx)
-    }
-
-    #[allow(unused_mut)]
-    fn poll_shutdown(
-        mut self: Pin<&mut Self>,
-        cx: &mut task::Context<'_>,
-    ) -> Poll<std::io::Result<()>> {
-        Pin::new(&mut *self.write.lock()).poll_shutdown(cx)
-    }
-}
-
-impl Drop for DuplexStream {
-    fn drop(&mut self) {
-        // notify the other side of the closure
-        self.write.lock().close_write();
-        self.read.lock().close_read();
-    }
-}
-
-// ===== impl Pipe =====
-
-impl Pipe {
-    fn new(max_buf_size: usize) -> Self {
-        Pipe {
-            buffer: BytesMut::new(),
-            is_closed: false,
-            max_buf_size,
-            read_waker: None,
-            write_waker: None,
-        }
-    }
-
-    fn close_write(&mut self) {
-        self.is_closed = true;
-        // needs to notify any readers that no more data will come
-        if let Some(waker) = self.read_waker.take() {
-            waker.wake();
-        }
-    }
-
-    fn close_read(&mut self) {
-        self.is_closed = true;
-        // needs to notify any writers that they have to abort
-        if let Some(waker) = self.write_waker.take() {
-            waker.wake();
-        }
-    }
-
-    fn poll_read_internal(
-        mut self: Pin<&mut Self>,
-        cx: &mut task::Context<'_>,
-        buf: &mut ReadBuf<'_>,
-    ) -> Poll<std::io::Result<()>> {
-        if self.buffer.has_remaining() {
-            let max = self.buffer.remaining().min(buf.remaining());
-            buf.put_slice(&self.buffer[..max]);
-            self.buffer.advance(max);
-            if max > 0 {
-                // The passed `buf` might have been empty, don't wake up if
-                // no bytes have been moved.
-                if let Some(waker) = self.write_waker.take() {
-                    waker.wake();
-                }
-            }
-            Poll::Ready(Ok(()))
-        } else if self.is_closed {
-            Poll::Ready(Ok(()))
-        } else {
-            self.read_waker = Some(cx.waker().clone());
-            Poll::Pending
-        }
-    }
-
-    fn poll_write_internal(
-        mut self: Pin<&mut Self>,
-        cx: &mut task::Context<'_>,
-        buf: &[u8],
-    ) -> Poll<std::io::Result<usize>> {
-        if self.is_closed {
-            return Poll::Ready(Err(std::io::ErrorKind::BrokenPipe.into()));
-        }
-        let avail = self.max_buf_size - self.buffer.len();
-        if avail == 0 {
-            self.write_waker = Some(cx.waker().clone());
-            return Poll::Pending;
-        }
-
-        let len = buf.len().min(avail);
-        self.buffer.extend_from_slice(&buf[..len]);
-        if let Some(waker) = self.read_waker.take() {
-            waker.wake();
-        }
-        Poll::Ready(Ok(len))
-    }
-
-    fn poll_write_vectored_internal(
-        mut self: Pin<&mut Self>,
-        cx: &mut task::Context<'_>,
-        bufs: &[std::io::IoSlice<'_>],
-    ) -> Poll<Result<usize, std::io::Error>> {
-        if self.is_closed {
-            return Poll::Ready(Err(std::io::ErrorKind::BrokenPipe.into()));
-        }
-        let avail = self.max_buf_size - self.buffer.len();
-        if avail == 0 {
-            self.write_waker = Some(cx.waker().clone());
-            return Poll::Pending;
-        }
-
-        let mut rem = avail;
-        for buf in bufs {
-            if rem == 0 {
-                break;
-            }
-
-            let len = buf.len().min(rem);
-            self.buffer.extend_from_slice(&buf[..len]);
-            rem -= len;
-        }
-
-        if let Some(waker) = self.read_waker.take() {
-            waker.wake();
-        }
-        Poll::Ready(Ok(avail - rem))
-    }
-}
-
-impl AsyncRead for Pipe {
-    cfg_coop! {
-        fn poll_read(
-            self: Pin<&mut Self>,
-            cx: &mut task::Context<'_>,
-            buf: &mut ReadBuf<'_>,
-        ) -> Poll<std::io::Result<()>> {
-            ready!(crate::trace::trace_leaf(cx));
-            let coop = ready!(crate::runtime::coop::poll_proceed(cx));
-
-            let ret = self.poll_read_internal(cx, buf);
-            if ret.is_ready() {
-                coop.made_progress();
-            }
-            ret
-        }
-    }
-
-    cfg_not_coop! {
-        fn poll_read(
-            self: Pin<&mut Self>,
-            cx: &mut task::Context<'_>,
-            buf: &mut ReadBuf<'_>,
-        ) -> Poll<std::io::Result<()>> {
-            ready!(crate::trace::trace_leaf(cx));
-            self.poll_read_internal(cx, buf)
-        }
-    }
-}
-
-impl AsyncWrite for Pipe {
-    cfg_coop! {
-        fn poll_write(
-            self: Pin<&mut Self>,
-            cx: &mut task::Context<'_>,
-            buf: &[u8],
-        ) -> Poll<std::io::Result<usize>> {
-            ready!(crate::trace::trace_leaf(cx));
-            let coop = ready!(crate::runtime::coop::poll_proceed(cx));
-
-            let ret = self.poll_write_internal(cx, buf);
-            if ret.is_ready() {
-                coop.made_progress();
-            }
-            ret
-        }
-    }
-
-    cfg_not_coop! {
-        fn poll_write(
-            self: Pin<&mut Self>,
-            cx: &mut task::Context<'_>,
-            buf: &[u8],
-        ) -> Poll<std::io::Result<usize>> {
-            ready!(crate::trace::trace_leaf(cx));
-            self.poll_write_internal(cx, buf)
-        }
-    }
-
-    cfg_coop! {
-        fn poll_write_vectored(
-            self: Pin<&mut Self>,
-            cx: &mut task::Context<'_>,
-            bufs: &[std::io::IoSlice<'_>],
-        ) -> Poll<Result<usize, std::io::Error>> {
-            ready!(crate::trace::trace_leaf(cx));
-            let coop = ready!(crate::runtime::coop::poll_proceed(cx));
-
-            let ret = self.poll_write_vectored_internal(cx, bufs);
-            if ret.is_ready() {
-                coop.made_progress();
-            }
-            ret
-        }
-    }
-
-    cfg_not_coop! {
-        fn poll_write_vectored(
-            self: Pin<&mut Self>,
-            cx: &mut task::Context<'_>,
-            bufs: &[std::io::IoSlice<'_>],
-        ) -> Poll<Result<usize, std::io::Error>> {
-            ready!(crate::trace::trace_leaf(cx));
-            self.poll_write_vectored_internal(cx, bufs)
-        }
-    }
-
-    fn is_write_vectored(&self) -> bool {
-        true
-    }
-
-    fn poll_flush(self: Pin<&mut Self>, _: &mut task::Context<'_>) -> Poll<std::io::Result<()>> {
-        Poll::Ready(Ok(()))
-    }
-
-    fn poll_shutdown(
-        mut self: Pin<&mut Self>,
-        _: &mut task::Context<'_>,
-    ) -> Poll<std::io::Result<()>> {
-        self.close_write();
-        Poll::Ready(Ok(()))
-    }
-}