wasmtime 25.0.1 → 25.0.2

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

@@ -1,144 +0,0 @@
-use crate::io::{AsyncBufRead, AsyncRead, ReadBuf};
-
-use pin_project_lite::pin_project;
-use std::fmt;
-use std::io;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-
-pin_project! {
-    /// Stream for the [`chain`](super::AsyncReadExt::chain) method.
-    #[must_use = "streams do nothing unless polled"]
-    #[cfg_attr(docsrs, doc(cfg(feature = "io-util")))]
-    pub struct Chain<T, U> {
-        #[pin]
-        first: T,
-        #[pin]
-        second: U,
-        done_first: bool,
-    }
-}
-
-pub(super) fn chain<T, U>(first: T, second: U) -> Chain<T, U>
-where
-    T: AsyncRead,
-    U: AsyncRead,
-{
-    Chain {
-        first,
-        second,
-        done_first: false,
-    }
-}
-
-impl<T, U> Chain<T, U>
-where
-    T: AsyncRead,
-    U: AsyncRead,
-{
-    /// Gets references to the underlying readers in this `Chain`.
-    pub fn get_ref(&self) -> (&T, &U) {
-        (&self.first, &self.second)
-    }
-
-    /// Gets mutable references to the underlying readers in this `Chain`.
-    ///
-    /// Care should be taken to avoid modifying the internal I/O state of the
-    /// underlying readers as doing so may corrupt the internal state of this
-    /// `Chain`.
-    pub fn get_mut(&mut self) -> (&mut T, &mut U) {
-        (&mut self.first, &mut self.second)
-    }
-
-    /// Gets pinned mutable references to the underlying readers in this `Chain`.
-    ///
-    /// Care should be taken to avoid modifying the internal I/O state of the
-    /// underlying readers as doing so may corrupt the internal state of this
-    /// `Chain`.
-    pub fn get_pin_mut(self: Pin<&mut Self>) -> (Pin<&mut T>, Pin<&mut U>) {
-        let me = self.project();
-        (me.first, me.second)
-    }
-
-    /// Consumes the `Chain`, returning the wrapped readers.
-    pub fn into_inner(self) -> (T, U) {
-        (self.first, self.second)
-    }
-}
-
-impl<T, U> fmt::Debug for Chain<T, U>
-where
-    T: fmt::Debug,
-    U: fmt::Debug,
-{
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("Chain")
-            .field("t", &self.first)
-            .field("u", &self.second)
-            .finish()
-    }
-}
-
-impl<T, U> AsyncRead for Chain<T, U>
-where
-    T: AsyncRead,
-    U: AsyncRead,
-{
-    fn poll_read(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &mut ReadBuf<'_>,
-    ) -> Poll<io::Result<()>> {
-        let me = self.project();
-
-        if !*me.done_first {
-            let rem = buf.remaining();
-            ready!(me.first.poll_read(cx, buf))?;
-            if buf.remaining() == rem {
-                *me.done_first = true;
-            } else {
-                return Poll::Ready(Ok(()));
-            }
-        }
-        me.second.poll_read(cx, buf)
-    }
-}
-
-impl<T, U> AsyncBufRead for Chain<T, U>
-where
-    T: AsyncBufRead,
-    U: AsyncBufRead,
-{
-    fn poll_fill_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<&[u8]>> {
-        let me = self.project();
-
-        if !*me.done_first {
-            match ready!(me.first.poll_fill_buf(cx)?) {
-                [] => {
-                    *me.done_first = true;
-                }
-                buf => return Poll::Ready(Ok(buf)),
-            }
-        }
-        me.second.poll_fill_buf(cx)
-    }
-
-    fn consume(self: Pin<&mut Self>, amt: usize) {
-        let me = self.project();
-        if !*me.done_first {
-            me.first.consume(amt)
-        } else {
-            me.second.consume(amt)
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn assert_unpin() {
-        crate::is_unpin::<Chain<(), ()>>();
-    }
-}

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

@@ -1,295 +0,0 @@
-use crate::io::{AsyncRead, AsyncWrite, ReadBuf};
-
-use std::future::Future;
-use std::io;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-
-#[derive(Debug)]
-pub(super) struct CopyBuffer {
-    read_done: bool,
-    need_flush: bool,
-    pos: usize,
-    cap: usize,
-    amt: u64,
-    buf: Box<[u8]>,
-}
-
-impl CopyBuffer {
-    pub(super) fn new(buf_size: usize) -> Self {
-        Self {
-            read_done: false,
-            need_flush: false,
-            pos: 0,
-            cap: 0,
-            amt: 0,
-            buf: vec![0; buf_size].into_boxed_slice(),
-        }
-    }
-
-    fn poll_fill_buf<R>(
-        &mut self,
-        cx: &mut Context<'_>,
-        reader: Pin<&mut R>,
-    ) -> Poll<io::Result<()>>
-    where
-        R: AsyncRead + ?Sized,
-    {
-        let me = &mut *self;
-        let mut buf = ReadBuf::new(&mut me.buf);
-        buf.set_filled(me.cap);
-
-        let res = reader.poll_read(cx, &mut buf);
-        if let Poll::Ready(Ok(())) = res {
-            let filled_len = buf.filled().len();
-            me.read_done = me.cap == filled_len;
-            me.cap = filled_len;
-        }
-        res
-    }
-
-    fn poll_write_buf<R, W>(
-        &mut self,
-        cx: &mut Context<'_>,
-        mut reader: Pin<&mut R>,
-        mut writer: Pin<&mut W>,
-    ) -> Poll<io::Result<usize>>
-    where
-        R: AsyncRead + ?Sized,
-        W: AsyncWrite + ?Sized,
-    {
-        let me = &mut *self;
-        match writer.as_mut().poll_write(cx, &me.buf[me.pos..me.cap]) {
-            Poll::Pending => {
-                // Top up the buffer towards full if we can read a bit more
-                // data - this should improve the chances of a large write
-                if !me.read_done && me.cap < me.buf.len() {
-                    ready!(me.poll_fill_buf(cx, reader.as_mut()))?;
-                }
-                Poll::Pending
-            }
-            res => res,
-        }
-    }
-
-    pub(super) fn poll_copy<R, W>(
-        &mut self,
-        cx: &mut Context<'_>,
-        mut reader: Pin<&mut R>,
-        mut writer: Pin<&mut W>,
-    ) -> Poll<io::Result<u64>>
-    where
-        R: AsyncRead + ?Sized,
-        W: AsyncWrite + ?Sized,
-    {
-        ready!(crate::trace::trace_leaf(cx));
-        #[cfg(any(
-            feature = "fs",
-            feature = "io-std",
-            feature = "net",
-            feature = "process",
-            feature = "rt",
-            feature = "signal",
-            feature = "sync",
-            feature = "time",
-        ))]
-        // Keep track of task budget
-        let coop = ready!(crate::runtime::coop::poll_proceed(cx));
-        loop {
-            // If there is some space left in our buffer, then we try to read some
-            // data to continue, thus maximizing the chances of a large write.
-            if self.cap < self.buf.len() && !self.read_done {
-                match self.poll_fill_buf(cx, reader.as_mut()) {
-                    Poll::Ready(Ok(())) => {
-                        #[cfg(any(
-                            feature = "fs",
-                            feature = "io-std",
-                            feature = "net",
-                            feature = "process",
-                            feature = "rt",
-                            feature = "signal",
-                            feature = "sync",
-                            feature = "time",
-                        ))]
-                        coop.made_progress();
-                    }
-                    Poll::Ready(Err(err)) => {
-                        #[cfg(any(
-                            feature = "fs",
-                            feature = "io-std",
-                            feature = "net",
-                            feature = "process",
-                            feature = "rt",
-                            feature = "signal",
-                            feature = "sync",
-                            feature = "time",
-                        ))]
-                        coop.made_progress();
-                        return Poll::Ready(Err(err));
-                    }
-                    Poll::Pending => {
-                        // Ignore pending reads when our buffer is not empty, because
-                        // we can try to write data immediately.
-                        if self.pos == self.cap {
-                            // Try flushing when the reader has no progress to avoid deadlock
-                            // when the reader depends on buffered writer.
-                            if self.need_flush {
-                                ready!(writer.as_mut().poll_flush(cx))?;
-                                #[cfg(any(
-                                    feature = "fs",
-                                    feature = "io-std",
-                                    feature = "net",
-                                    feature = "process",
-                                    feature = "rt",
-                                    feature = "signal",
-                                    feature = "sync",
-                                    feature = "time",
-                                ))]
-                                coop.made_progress();
-                                self.need_flush = false;
-                            }
-
-                            return Poll::Pending;
-                        }
-                    }
-                }
-            }
-
-            // If our buffer has some data, let's write it out!
-            while self.pos < self.cap {
-                let i = ready!(self.poll_write_buf(cx, reader.as_mut(), writer.as_mut()))?;
-                #[cfg(any(
-                    feature = "fs",
-                    feature = "io-std",
-                    feature = "net",
-                    feature = "process",
-                    feature = "rt",
-                    feature = "signal",
-                    feature = "sync",
-                    feature = "time",
-                ))]
-                coop.made_progress();
-                if i == 0 {
-                    return Poll::Ready(Err(io::Error::new(
-                        io::ErrorKind::WriteZero,
-                        "write zero byte into writer",
-                    )));
-                } else {
-                    self.pos += i;
-                    self.amt += i as u64;
-                    self.need_flush = true;
-                }
-            }
-
-            // If pos larger than cap, this loop will never stop.
-            // In particular, user's wrong poll_write implementation returning
-            // incorrect written length may lead to thread blocking.
-            debug_assert!(
-                self.pos <= self.cap,
-                "writer returned length larger than input slice"
-            );
-
-            // All data has been written, the buffer can be considered empty again
-            self.pos = 0;
-            self.cap = 0;
-
-            // If we've written all the data and we've seen EOF, flush out the
-            // data and finish the transfer.
-            if self.read_done {
-                ready!(writer.as_mut().poll_flush(cx))?;
-                #[cfg(any(
-                    feature = "fs",
-                    feature = "io-std",
-                    feature = "net",
-                    feature = "process",
-                    feature = "rt",
-                    feature = "signal",
-                    feature = "sync",
-                    feature = "time",
-                ))]
-                coop.made_progress();
-                return Poll::Ready(Ok(self.amt));
-            }
-        }
-    }
-}
-
-/// A future that asynchronously copies the entire contents of a reader into a
-/// writer.
-#[derive(Debug)]
-#[must_use = "futures do nothing unless you `.await` or poll them"]
-struct Copy<'a, R: ?Sized, W: ?Sized> {
-    reader: &'a mut R,
-    writer: &'a mut W,
-    buf: CopyBuffer,
-}
-
-cfg_io_util! {
-    /// Asynchronously copies the entire contents of a reader into a writer.
-    ///
-    /// This function returns a future that will continuously read data from
-    /// `reader` and then write it into `writer` in a streaming fashion until
-    /// `reader` returns EOF or fails.
-    ///
-    /// On success, the total number of bytes that were copied from `reader` to
-    /// `writer` is returned.
-    ///
-    /// This is an asynchronous version of [`std::io::copy`][std].
-    ///
-    /// A heap-allocated copy buffer with 8 KB is created to take data from the
-    /// reader to the writer, check [`copy_buf`] if you want an alternative for
-    /// [`AsyncBufRead`]. You can use `copy_buf` with [`BufReader`] to change the
-    /// buffer capacity.
-    ///
-    /// [std]: std::io::copy
-    /// [`copy_buf`]: crate::io::copy_buf
-    /// [`AsyncBufRead`]: crate::io::AsyncBufRead
-    /// [`BufReader`]: crate::io::BufReader
-    ///
-    /// # Errors
-    ///
-    /// The returned future will return an error immediately if any call to
-    /// `poll_read` or `poll_write` returns an error.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use tokio::io;
-    ///
-    /// # async fn dox() -> std::io::Result<()> {
-    /// let mut reader: &[u8] = b"hello";
-    /// let mut writer: Vec<u8> = vec![];
-    ///
-    /// io::copy(&mut reader, &mut writer).await?;
-    ///
-    /// assert_eq!(&b"hello"[..], &writer[..]);
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub async fn copy<'a, R, W>(reader: &'a mut R, writer: &'a mut W) -> io::Result<u64>
-    where
-        R: AsyncRead + Unpin + ?Sized,
-        W: AsyncWrite + Unpin + ?Sized,
-    {
-        Copy {
-            reader,
-            writer,
-            buf: CopyBuffer::new(super::DEFAULT_BUF_SIZE)
-        }.await
-    }
-}
-
-impl<R, W> Future for Copy<'_, R, W>
-where
-    R: AsyncRead + Unpin + ?Sized,
-    W: AsyncWrite + Unpin + ?Sized,
-{
-    type Output = io::Result<u64>;
-
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<u64>> {
-        let me = &mut *self;
-
-        me.buf
-            .poll_copy(cx, Pin::new(&mut *me.reader), Pin::new(&mut *me.writer))
-    }
-}

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

@@ -1,137 +0,0 @@
-use super::copy::CopyBuffer;
-
-use crate::future::poll_fn;
-use crate::io::{AsyncRead, AsyncWrite};
-
-use std::io;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-
-enum TransferState {
-    Running(CopyBuffer),
-    ShuttingDown(u64),
-    Done(u64),
-}
-
-fn transfer_one_direction<A, B>(
-    cx: &mut Context<'_>,
-    state: &mut TransferState,
-    r: &mut A,
-    w: &mut B,
-) -> Poll<io::Result<u64>>
-where
-    A: AsyncRead + AsyncWrite + Unpin + ?Sized,
-    B: AsyncRead + AsyncWrite + Unpin + ?Sized,
-{
-    let mut r = Pin::new(r);
-    let mut w = Pin::new(w);
-
-    loop {
-        match state {
-            TransferState::Running(buf) => {
-                let count = ready!(buf.poll_copy(cx, r.as_mut(), w.as_mut()))?;
-                *state = TransferState::ShuttingDown(count);
-            }
-            TransferState::ShuttingDown(count) => {
-                ready!(w.as_mut().poll_shutdown(cx))?;
-
-                *state = TransferState::Done(*count);
-            }
-            TransferState::Done(count) => return Poll::Ready(Ok(*count)),
-        }
-    }
-}
-/// Copies data in both directions between `a` and `b`.
-///
-/// This function returns a future that will read from both streams,
-/// writing any data read to the opposing stream.
-/// This happens in both directions concurrently.
-///
-/// If an EOF is observed on one stream, [`shutdown()`] will be invoked on
-/// the other, and reading from that stream will stop. Copying of data in
-/// the other direction will continue.
-///
-/// The future will complete successfully once both directions of communication has been shut down.
-/// A direction is shut down when the reader reports EOF,
-/// at which point [`shutdown()`] is called on the corresponding writer. When finished,
-/// it will return a tuple of the number of bytes copied from a to b
-/// and the number of bytes copied from b to a, in that order.
-///
-/// It uses two 8 KB buffers for transferring bytes between `a` and `b` by default.
-/// To set your own buffers sizes use [`copy_bidirectional_with_sizes()`].
-///
-/// [`shutdown()`]: crate::io::AsyncWriteExt::shutdown
-///
-/// # Errors
-///
-/// The future will immediately return an error if any IO operation on `a`
-/// or `b` returns an error. Some data read from either stream may be lost (not
-/// written to the other stream) in this case.
-///
-/// # Return value
-///
-/// Returns a tuple of bytes copied `a` to `b` and bytes copied `b` to `a`.
-#[cfg_attr(docsrs, doc(cfg(feature = "io-util")))]
-pub async fn copy_bidirectional<A, B>(a: &mut A, b: &mut B) -> io::Result<(u64, u64)>
-where
-    A: AsyncRead + AsyncWrite + Unpin + ?Sized,
-    B: AsyncRead + AsyncWrite + Unpin + ?Sized,
-{
-    copy_bidirectional_impl(
-        a,
-        b,
-        CopyBuffer::new(super::DEFAULT_BUF_SIZE),
-        CopyBuffer::new(super::DEFAULT_BUF_SIZE),
-    )
-    .await
-}
-
-/// Copies data in both directions between `a` and `b` using buffers of the specified size.
-///
-/// This method is the same as the [`copy_bidirectional()`], except that it allows you to set the
-/// size of the internal buffers used when copying data.
-#[cfg_attr(docsrs, doc(cfg(feature = "io-util")))]
-pub async fn copy_bidirectional_with_sizes<A, B>(
-    a: &mut A,
-    b: &mut B,
-    a_to_b_buf_size: usize,
-    b_to_a_buf_size: usize,
-) -> io::Result<(u64, u64)>
-where
-    A: AsyncRead + AsyncWrite + Unpin + ?Sized,
-    B: AsyncRead + AsyncWrite + Unpin + ?Sized,
-{
-    copy_bidirectional_impl(
-        a,
-        b,
-        CopyBuffer::new(a_to_b_buf_size),
-        CopyBuffer::new(b_to_a_buf_size),
-    )
-    .await
-}
-
-async fn copy_bidirectional_impl<A, B>(
-    a: &mut A,
-    b: &mut B,
-    a_to_b_buffer: CopyBuffer,
-    b_to_a_buffer: CopyBuffer,
-) -> io::Result<(u64, u64)>
-where
-    A: AsyncRead + AsyncWrite + Unpin + ?Sized,
-    B: AsyncRead + AsyncWrite + Unpin + ?Sized,
-{
-    let mut a_to_b = TransferState::Running(a_to_b_buffer);
-    let mut b_to_a = TransferState::Running(b_to_a_buffer);
-    poll_fn(|cx| {
-        let a_to_b = transfer_one_direction(cx, &mut a_to_b, a, b)?;
-        let b_to_a = transfer_one_direction(cx, &mut b_to_a, b, a)?;
-
-        // It is not a problem if ready! returns early because transfer_one_direction for the
-        // other direction will keep returning TransferState::Done(count) in future calls to poll
-        let a_to_b = ready!(a_to_b);
-        let b_to_a = ready!(b_to_a);
-
-        Poll::Ready(Ok((a_to_b, b_to_a)))
-    })
-    .await
-}

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

@@ -1,108 +0,0 @@
-use crate::io::{AsyncBufRead, AsyncWrite};
-use std::future::Future;
-use std::io;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-
-cfg_io_util! {
-    /// A future that asynchronously copies the entire contents of a reader into a
-    /// writer.
-    ///
-    /// This struct is generally created by calling [`copy_buf`][copy_buf]. Please
-    /// see the documentation of `copy_buf()` for more details.
-    ///
-    /// [copy_buf]: copy_buf()
-    #[derive(Debug)]
-    #[must_use = "futures do nothing unless you `.await` or poll them"]
-    struct CopyBuf<'a, R: ?Sized, W: ?Sized> {
-        reader: &'a mut R,
-        writer: &'a mut W,
-        amt: u64,
-    }
-
-    /// Asynchronously copies the entire contents of a reader into a writer.
-    ///
-    /// This function returns a future that will continuously read data from
-    /// `reader` and then write it into `writer` in a streaming fashion until
-    /// `reader` returns EOF or fails.
-    ///
-    /// On success, the total number of bytes that were copied from `reader` to
-    /// `writer` is returned.
-    ///
-    /// This is a [`tokio::io::copy`] alternative for [`AsyncBufRead`] readers
-    /// with no extra buffer allocation, since [`AsyncBufRead`] allow access
-    /// to the reader's inner buffer.
-    ///
-    /// [`tokio::io::copy`]: crate::io::copy
-    /// [`AsyncBufRead`]: crate::io::AsyncBufRead
-    ///
-    /// # Errors
-    ///
-    /// The returned future will finish with an error will return an error
-    /// immediately if any call to `poll_fill_buf` or `poll_write` returns an
-    /// error.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use tokio::io;
-    ///
-    /// # async fn dox() -> std::io::Result<()> {
-    /// let mut reader: &[u8] = b"hello";
-    /// let mut writer: Vec<u8> = vec![];
-    ///
-    /// io::copy_buf(&mut reader, &mut writer).await?;
-    ///
-    /// assert_eq!(b"hello", &writer[..]);
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub async fn copy_buf<'a, R, W>(reader: &'a mut R, writer: &'a mut W) -> io::Result<u64>
-    where
-        R: AsyncBufRead + Unpin + ?Sized,
-        W: AsyncWrite + Unpin + ?Sized,
-    {
-        CopyBuf {
-            reader,
-            writer,
-            amt: 0,
-        }.await
-    }
-}
-
-impl<R, W> Future for CopyBuf<'_, R, W>
-where
-    R: AsyncBufRead + Unpin + ?Sized,
-    W: AsyncWrite + Unpin + ?Sized,
-{
-    type Output = io::Result<u64>;
-
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        loop {
-            let me = &mut *self;
-            let buffer = ready!(Pin::new(&mut *me.reader).poll_fill_buf(cx))?;
-            if buffer.is_empty() {
-                ready!(Pin::new(&mut self.writer).poll_flush(cx))?;
-                return Poll::Ready(Ok(self.amt));
-            }
-
-            let i = ready!(Pin::new(&mut *me.writer).poll_write(cx, buffer))?;
-            if i == 0 {
-                return Poll::Ready(Err(std::io::ErrorKind::WriteZero.into()));
-            }
-            self.amt += i as u64;
-            Pin::new(&mut *self.reader).consume(i);
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn assert_unpin() {
-        use std::marker::PhantomPinned;
-        crate::is_unpin::<CopyBuf<'_, PhantomPinned, PhantomPinned>>();
-    }
-}