ashlr-plugin 1.36.4

package/bench/refs/rust-project/tokio/src/io/stdin.rs

@@ -0,0 +1,98 @@
+use crate::io::blocking::Blocking;
+use crate::io::{AsyncRead, ReadBuf};
+
+use std::io;
+use std::pin::Pin;
+use std::task::Context;
+use std::task::Poll;
+
+cfg_io_std! {
+    /// A handle to the standard input stream of a process.
+    ///
+    /// The handle implements the [`AsyncRead`] trait, but beware that concurrent
+    /// reads of `Stdin` must be executed with care.
+    ///
+    /// This handle is best used for non-interactive uses, such as when a file
+    /// is piped into the application. For technical reasons, `stdin` is
+    /// implemented by using an ordinary blocking read on a separate thread, and
+    /// it is impossible to cancel that read. This can make shutdown of the
+    /// runtime hang until the user presses enter.
+    ///
+    /// For interactive uses, it is recommended to spawn a thread dedicated to
+    /// user input and use blocking IO directly in that thread.
+    ///
+    /// Created by the [`stdin`] function.
+    ///
+    /// [`stdin`]: fn@stdin
+    /// [`AsyncRead`]: trait@AsyncRead
+    #[derive(Debug)]
+    pub struct Stdin {
+        std: Blocking<std::io::Stdin>,
+    }
+
+    /// Constructs a new handle to the standard input of the current process.
+    ///
+    /// This handle is best used for non-interactive uses, such as when a file
+    /// is piped into the application. For technical reasons, `stdin` is
+    /// implemented by using an ordinary blocking read on a separate thread, and
+    /// it is impossible to cancel that read. This can make shutdown of the
+    /// runtime hang until the user presses enter.
+    ///
+    /// For interactive uses, it is recommended to spawn a thread dedicated to
+    /// user input and use blocking IO directly in that thread.
+    pub fn stdin() -> Stdin {
+        let std = io::stdin();
+        // SAFETY: The `Read` implementation of `std` does not read from the
+        // buffer it is borrowing and correctly reports the length of the data
+        // written into the buffer.
+        let std = unsafe { Blocking::new(std) };
+        Stdin {
+            std,
+        }
+    }
+}
+
+#[cfg(unix)]
+mod sys {
+    use std::os::unix::io::{AsFd, AsRawFd, BorrowedFd, RawFd};
+
+    use super::Stdin;
+
+    impl AsRawFd for Stdin {
+        fn as_raw_fd(&self) -> RawFd {
+            std::io::stdin().as_raw_fd()
+        }
+    }
+
+    impl AsFd for Stdin {
+        fn as_fd(&self) -> BorrowedFd<'_> {
+            unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) }
+        }
+    }
+}
+
+cfg_windows! {
+    use crate::os::windows::io::{AsHandle, BorrowedHandle, AsRawHandle, RawHandle};
+
+    impl AsRawHandle for Stdin {
+        fn as_raw_handle(&self) -> RawHandle {
+            std::io::stdin().as_raw_handle()
+        }
+    }
+
+    impl AsHandle for Stdin {
+        fn as_handle(&self) -> BorrowedHandle<'_> {
+            unsafe { BorrowedHandle::borrow_raw(self.as_raw_handle()) }
+        }
+    }
+}
+
+impl AsyncRead for Stdin {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.std).poll_read(cx, buf)
+    }
+}

package/bench/refs/rust-project/tokio/src/io/stdio_common.rs

@@ -0,0 +1,222 @@
+//! Contains utilities for stdout and stderr.
+use crate::io::AsyncWrite;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+/// # Windows
+/// [`AsyncWrite`] adapter that finds last char boundary in given buffer and does not write the rest,
+/// if buffer contents seems to be `utf8`. Otherwise it only trims buffer down to `DEFAULT_MAX_BUF_SIZE`.
+/// That's why, wrapped writer will always receive well-formed utf-8 bytes.
+/// # Other platforms
+/// Passes data to `inner` as is.
+#[derive(Debug)]
+pub(crate) struct SplitByUtf8BoundaryIfWindows<W> {
+    inner: W,
+}
+
+impl<W> SplitByUtf8BoundaryIfWindows<W> {
+    pub(crate) fn new(inner: W) -> Self {
+        Self { inner }
+    }
+}
+
+// this constant is defined by Unicode standard.
+const MAX_BYTES_PER_CHAR: usize = 4;
+
+// Subject for tweaking here
+const MAGIC_CONST: usize = 8;
+
+impl<W> crate::io::AsyncWrite for SplitByUtf8BoundaryIfWindows<W>
+where
+    W: AsyncWrite + Unpin,
+{
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        mut buf: &[u8],
+    ) -> Poll<Result<usize, std::io::Error>> {
+        // just a closure to avoid repetitive code
+        let mut call_inner = move |buf| Pin::new(&mut self.inner).poll_write(cx, buf);
+
+        // 1. Only windows stdio can suffer from non-utf8.
+        // We also check for `test` so that we can write some tests
+        // for further code. Since `AsyncWrite` can always shrink
+        // buffer at its discretion, excessive (i.e. in tests) shrinking
+        // does not break correctness.
+        // 2. If buffer is small, it will not be shrunk.
+        // That's why, it's "textness" will not change, so we don't have
+        // to fixup it.
+        if cfg!(not(any(target_os = "windows", test)))
+            || buf.len() <= crate::io::blocking::DEFAULT_MAX_BUF_SIZE
+        {
+            return call_inner(buf);
+        }
+
+        buf = &buf[..crate::io::blocking::DEFAULT_MAX_BUF_SIZE];
+
+        // Now there are two possibilities.
+        // If caller gave is binary buffer, we **should not** shrink it
+        // anymore, because excessive shrinking hits performance.
+        // If caller gave as binary buffer, we  **must** additionally
+        // shrink it to strip incomplete char at the end of buffer.
+        // that's why check we will perform now is allowed to have
+        // false-positive.
+
+        // Now let's look at the first MAX_BYTES_PER_CHAR * MAGIC_CONST bytes.
+        // if they are (possibly incomplete) utf8, then we can be quite sure
+        // that input buffer was utf8.
+
+        let have_to_fix_up = match std::str::from_utf8(&buf[..MAX_BYTES_PER_CHAR * MAGIC_CONST]) {
+            Ok(_) => true,
+            Err(err) => {
+                let incomplete_bytes = MAX_BYTES_PER_CHAR * MAGIC_CONST - err.valid_up_to();
+                incomplete_bytes < MAX_BYTES_PER_CHAR
+            }
+        };
+
+        if have_to_fix_up {
+            // We must pop several bytes at the end which form incomplete
+            // character. To achieve it, we exploit UTF8 encoding:
+            // for any code point, all bytes except first start with 0b10 prefix.
+            // see https://en.wikipedia.org/wiki/UTF-8#Encoding for details
+            let trailing_incomplete_char_size = buf
+                .iter()
+                .rev()
+                .take(MAX_BYTES_PER_CHAR)
+                .position(|byte| *byte < 0b1000_0000 || *byte >= 0b1100_0000)
+                .unwrap_or(0)
+                + 1;
+            buf = &buf[..buf.len() - trailing_incomplete_char_size];
+        }
+
+        call_inner(buf)
+    }
+
+    fn poll_flush(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<(), std::io::Error>> {
+        Pin::new(&mut self.inner).poll_flush(cx)
+    }
+
+    fn poll_shutdown(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<(), std::io::Error>> {
+        Pin::new(&mut self.inner).poll_shutdown(cx)
+    }
+}
+
+#[cfg(test)]
+#[cfg(not(loom))]
+mod tests {
+    use crate::io::blocking::DEFAULT_MAX_BUF_SIZE;
+    use crate::io::AsyncWriteExt;
+    use std::io;
+    use std::pin::Pin;
+    use std::task::Context;
+    use std::task::Poll;
+
+    struct TextMockWriter;
+
+    impl crate::io::AsyncWrite for TextMockWriter {
+        fn poll_write(
+            self: Pin<&mut Self>,
+            _cx: &mut Context<'_>,
+            buf: &[u8],
+        ) -> Poll<Result<usize, io::Error>> {
+            assert!(buf.len() <= DEFAULT_MAX_BUF_SIZE);
+            assert!(std::str::from_utf8(buf).is_ok());
+            Poll::Ready(Ok(buf.len()))
+        }
+
+        fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
+            Poll::Ready(Ok(()))
+        }
+
+        fn poll_shutdown(
+            self: Pin<&mut Self>,
+            _cx: &mut Context<'_>,
+        ) -> Poll<Result<(), io::Error>> {
+            Poll::Ready(Ok(()))
+        }
+    }
+
+    struct LoggingMockWriter {
+        write_history: Vec<usize>,
+    }
+
+    impl LoggingMockWriter {
+        fn new() -> Self {
+            LoggingMockWriter {
+                write_history: Vec::new(),
+            }
+        }
+    }
+
+    impl crate::io::AsyncWrite for LoggingMockWriter {
+        fn poll_write(
+            mut self: Pin<&mut Self>,
+            _cx: &mut Context<'_>,
+            buf: &[u8],
+        ) -> Poll<Result<usize, io::Error>> {
+            assert!(buf.len() <= DEFAULT_MAX_BUF_SIZE);
+            self.write_history.push(buf.len());
+            Poll::Ready(Ok(buf.len()))
+        }
+
+        fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
+            Poll::Ready(Ok(()))
+        }
+
+        fn poll_shutdown(
+            self: Pin<&mut Self>,
+            _cx: &mut Context<'_>,
+        ) -> Poll<Result<(), io::Error>> {
+            Poll::Ready(Ok(()))
+        }
+    }
+
+    #[test]
+    #[cfg_attr(miri, ignore)] // takes a really long time with miri
+    fn test_splitter() {
+        let data = str::repeat("█", DEFAULT_MAX_BUF_SIZE);
+        let mut wr = super::SplitByUtf8BoundaryIfWindows::new(TextMockWriter);
+        let fut = async move {
+            wr.write_all(data.as_bytes()).await.unwrap();
+        };
+        crate::runtime::Builder::new_current_thread()
+            .build()
+            .unwrap()
+            .block_on(fut);
+    }
+
+    #[test]
+    #[cfg_attr(miri, ignore)] // takes a really long time with miri
+    fn test_pseudo_text() {
+        // In this test we write a piece of binary data, whose beginning is
+        // text though. We then validate that even in this corner case buffer
+        // was not shrunk too much.
+        let checked_count = super::MAGIC_CONST * super::MAX_BYTES_PER_CHAR;
+        let mut data: Vec<u8> = str::repeat("a", checked_count).into();
+        data.extend(std::iter::repeat(0b1010_1010).take(DEFAULT_MAX_BUF_SIZE - checked_count + 1));
+        let mut writer = LoggingMockWriter::new();
+        let mut splitter = super::SplitByUtf8BoundaryIfWindows::new(&mut writer);
+        crate::runtime::Builder::new_current_thread()
+            .build()
+            .unwrap()
+            .block_on(async {
+                splitter.write_all(&data).await.unwrap();
+            });
+        // Check that at most two writes were performed
+        assert!(writer.write_history.len() <= 2);
+        // Check that all has been written
+        assert_eq!(
+            writer.write_history.iter().copied().sum::<usize>(),
+            data.len()
+        );
+        // Check that at most MAX_BYTES_PER_CHAR + 1 (i.e. 5) bytes were shrunk
+        // from the buffer: one because it was outside of DEFAULT_MAX_BUF_SIZE boundary, and
+        // up to one "utf8 code point".
+        assert!(data.len() - writer.write_history[0] <= super::MAX_BYTES_PER_CHAR + 1);
+    }
+}

package/bench/refs/rust-project/tokio/src/io/stdout.rs

@@ -0,0 +1,197 @@
+use crate::io::blocking::Blocking;
+use crate::io::stdio_common::SplitByUtf8BoundaryIfWindows;
+use crate::io::AsyncWrite;
+use std::io;
+use std::pin::Pin;
+use std::task::Context;
+use std::task::Poll;
+
+cfg_io_std! {
+    /// A handle to the standard output stream of a process.
+    ///
+    /// Concurrent writes to stdout must be executed with care: Only individual
+    /// writes to this [`AsyncWrite`] are guaranteed to be intact. In particular
+    /// you should be aware that writes using [`write_all`] are not guaranteed
+    /// to occur as a single write, so multiple threads writing data with
+    /// [`write_all`] may result in interleaved output.
+    ///
+    /// Created by the [`stdout`] function.
+    ///
+    /// [`stdout`]: stdout()
+    /// [`AsyncWrite`]: AsyncWrite
+    /// [`write_all`]: crate::io::AsyncWriteExt::write_all()
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use tokio::io::{self, AsyncWriteExt};
+    ///
+    /// #[tokio::main]
+    /// async fn main() -> io::Result<()> {
+    ///     let mut stdout = io::stdout();
+    ///     stdout.write_all(b"Hello world!").await?;
+    ///     Ok(())
+    /// }
+    /// ```
+    ///
+    /// The following is an example of using `stdio` with loop.
+    ///
+    /// ```
+    /// use tokio::io::{self, AsyncWriteExt};
+    ///
+    /// #[tokio::main]
+    /// async fn main() {
+    ///     let messages = vec!["hello", " world\n"];
+    ///
+    ///     // When you use `stdio` in a loop, it is recommended to create
+    ///     // a single `stdio` instance outside the loop and call a write
+    ///     // operation against that instance on each loop.
+    ///     //
+    ///     // Repeatedly creating `stdout` instances inside the loop and
+    ///     // writing to that handle could result in mangled output since
+    ///     // each write operation is handled by a different blocking thread.
+    ///     let mut stdout = io::stdout();
+    ///
+    ///     for message in &messages {
+    ///         stdout.write_all(message.as_bytes()).await.unwrap();
+    ///         stdout.flush().await.unwrap();
+    ///     }
+    /// }
+    /// ```
+    #[derive(Debug)]
+    pub struct Stdout {
+        std: SplitByUtf8BoundaryIfWindows<Blocking<std::io::Stdout>>,
+    }
+
+    /// Constructs a new handle to the standard output of the current process.
+    ///
+    /// The returned handle allows writing to standard out from the within the
+    /// Tokio runtime.
+    ///
+    /// Concurrent writes to stdout must be executed with care: Only individual
+    /// writes to this [`AsyncWrite`] are guaranteed to be intact. In particular
+    /// you should be aware that writes using [`write_all`] are not guaranteed
+    /// to occur as a single write, so multiple threads writing data with
+    /// [`write_all`] may result in interleaved output.
+    ///
+    /// Note that unlike [`std::io::stdout`], each call to this `stdout()`
+    /// produces a new writer, so for example, this program does **not** flush stdout:
+    ///
+    /// ```no_run
+    /// # use tokio::io::AsyncWriteExt;
+    /// # #[tokio::main]
+    /// # async fn main() -> std::io::Result<()> {
+    /// tokio::io::stdout().write_all(b"aa").await?;
+    /// tokio::io::stdout().flush().await?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// [`std::io::stdout`]: std::io::stdout
+    /// [`AsyncWrite`]: AsyncWrite
+    /// [`write_all`]: crate::io::AsyncWriteExt::write_all()
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use tokio::io::{self, AsyncWriteExt};
+    ///
+    /// #[tokio::main]
+    /// async fn main() -> io::Result<()> {
+    ///     let mut stdout = io::stdout();
+    ///     stdout.write_all(b"Hello world!").await?;
+    ///     Ok(())
+    /// }
+    /// ```
+    ///
+    /// The following is an example of using `stdio` with loop.
+    ///
+    /// ```
+    /// use tokio::io::{self, AsyncWriteExt};
+    ///
+    /// #[tokio::main]
+    /// async fn main() {
+    ///     let messages = vec!["hello", " world\n"];
+    ///
+    ///     // When you use `stdio` in a loop, it is recommended to create
+    ///     // a single `stdio` instance outside the loop and call a write
+    ///     // operation against that instance on each loop.
+    ///     //
+    ///     // Repeatedly creating `stdout` instances inside the loop and
+    ///     // writing to that handle could result in mangled output since
+    ///     // each write operation is handled by a different blocking thread.
+    ///     let mut stdout = io::stdout();
+    ///
+    ///     for message in &messages {
+    ///         stdout.write_all(message.as_bytes()).await.unwrap();
+    ///         stdout.flush().await.unwrap();
+    ///     }
+    /// }
+    /// ```
+    pub fn stdout() -> Stdout {
+        let std = io::stdout();
+        // SAFETY: The `Read` implementation of `std` does not read from the
+        // buffer it is borrowing and correctly reports the length of the data
+        // written into the buffer.
+        let blocking = unsafe { Blocking::new(std) };
+        Stdout {
+            std: SplitByUtf8BoundaryIfWindows::new(blocking),
+        }
+    }
+}
+
+#[cfg(unix)]
+mod sys {
+    use std::os::unix::io::{AsFd, AsRawFd, BorrowedFd, RawFd};
+
+    use super::Stdout;
+
+    impl AsRawFd for Stdout {
+        fn as_raw_fd(&self) -> RawFd {
+            std::io::stdout().as_raw_fd()
+        }
+    }
+
+    impl AsFd for Stdout {
+        fn as_fd(&self) -> BorrowedFd<'_> {
+            unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) }
+        }
+    }
+}
+
+cfg_windows! {
+    use crate::os::windows::io::{AsHandle, BorrowedHandle, AsRawHandle, RawHandle};
+
+    impl AsRawHandle for Stdout {
+        fn as_raw_handle(&self) -> RawHandle {
+            std::io::stdout().as_raw_handle()
+        }
+    }
+
+    impl AsHandle for Stdout {
+        fn as_handle(&self) -> BorrowedHandle<'_> {
+            unsafe { BorrowedHandle::borrow_raw(self.as_raw_handle()) }
+        }
+    }
+}
+
+impl AsyncWrite for Stdout {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        Pin::new(&mut self.std).poll_write(cx, buf)
+    }
+
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
+        Pin::new(&mut self.std).poll_flush(cx)
+    }
+
+    fn poll_shutdown(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<(), io::Error>> {
+        Pin::new(&mut self.std).poll_shutdown(cx)
+    }
+}