libstd: use block buffering when stdout is not a TTY

src/libstd/io/stdio.rs

@@ -5,7 +5,7 @@ use crate::io::prelude::*;
 use crate::cell::RefCell;
 use crate::fmt;
 use crate::io::lazy::Lazy;
-use crate::io::{self, Initializer, BufReader, LineWriter, IoSlice, IoSliceMut};
+use crate::io::{self, Initializer, BufReader, BufWriter, LineWriter, IoSlice, IoSliceMut};
 use crate::sync::{Arc, Mutex, MutexGuard};
 use crate::sys::stdio;
 use crate::sys_common::remutex::{ReentrantMutex, ReentrantMutexGuard};
@@ -398,10 +398,7 @@ impl fmt::Debug for StdinLock<'_> {
 /// [`io::stdout`]: fn.stdout.html
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct Stdout {
-    // FIXME: this should be LineWriter or BufWriter depending on the state of
-    //        stdout (tty or not). Note that if this is not line buffered it
-    //        should also flush-on-panic or some form of flush-on-abort.
-    inner: Arc<ReentrantMutex<RefCell<LineWriter<Maybe<StdoutRaw>>>>>,
+    inner: Arc<ReentrantMutex<RefCell<StdoutStream>>>,
 }
 
 /// A locked reference to the `Stdout` handle.
@@ -418,7 +415,7 @@ pub struct Stdout {
 /// [`Stdout::lock`]: struct.Stdout.html#method.lock
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct StdoutLock<'a> {
-    inner: ReentrantMutexGuard<'a, RefCell<LineWriter<Maybe<StdoutRaw>>>>,
+    inner: ReentrantMutexGuard<'a, RefCell<StdoutStream>>,
 }
 
 /// Constructs a new handle to the standard output of the current process.
@@ -464,20 +461,80 @@ pub struct StdoutLock<'a> {
 /// ```
 #[stable(feature = "rust1", since = "1.0.0")]
 pub fn stdout() -> Stdout {
-    static INSTANCE: Lazy<ReentrantMutex<RefCell<LineWriter<Maybe<StdoutRaw>>>>> = Lazy::new();
+    static INSTANCE: Lazy<ReentrantMutex<RefCell<StdoutStream>>> = Lazy::new();
     return Stdout {
         inner: unsafe {
             INSTANCE.get(stdout_init).expect("cannot access stdout during shutdown")
         },
     };
 
-    fn stdout_init() -> Arc<ReentrantMutex<RefCell<LineWriter<Maybe<StdoutRaw>>>>> {
+    fn stdout_init() -> Arc<ReentrantMutex<RefCell<StdoutStream>>> {
         // This must not reentrantly access `INSTANCE`
         let stdout = match stdout_raw() {
-            Ok(stdout) => Maybe::Real(stdout),
-            _ => Maybe::Fake,
+            Ok(stdout) => {
+                let tty = stdout.0.is_tty();
+                let stdout = Maybe::Real(stdout);
+                if tty {
+                    let inner = LineWriter::new(stdout);
+                    StdoutStream::LineBuffered(inner)
+                } else {
+                    let inner = BufWriter::with_capacity(stdio::STDOUT_BUF_SIZE, stdout);
+                    StdoutStream::BlockBuffered(inner)
+                }
+            }
+            _ => StdoutStream::LineBuffered(LineWriter::new(Maybe::Fake)),
         };
-        Arc::new(ReentrantMutex::new(RefCell::new(LineWriter::new(stdout))))
+        Arc::new(ReentrantMutex::new(RefCell::new(stdout)))
+    }
+}
+
+/// Container to allow switching between block buffering and line buffering for the process's
+/// standard output.
+enum StdoutStream {
+    BlockBuffered(BufWriter<Maybe<StdoutRaw>>),
+    LineBuffered(LineWriter<Maybe<StdoutRaw>>),
+}
+
+impl Write for StdoutStream {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        use self::StdoutStream::*;
+
+        match self {
+            BlockBuffered(w) => w.write(buf),
+            LineBuffered(w) => w.write(buf),
+        }
+    }
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        use self::StdoutStream::*;
+
+        match self {
+            BlockBuffered(w) => w.write_vectored(bufs),
+            LineBuffered(w) => w.write_vectored(bufs),
+        }
+    }
+    fn flush(&mut self) -> io::Result<()> {
+        use self::StdoutStream::*;
+
+        match self {
+            BlockBuffered(w) => w.flush(),
+            LineBuffered(w) => w.flush(),
+        }
+    }
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        use self::StdoutStream::*;
+
+        match self {
+            BlockBuffered(w) => w.write_all(buf),
+            LineBuffered(w) => w.write_all(buf)
+        }
+    }
+    fn write_fmt(&mut self, args: fmt::Arguments<'_>) -> io::Result<()> {
+        use self::StdoutStream::*;
+
+        match self {
+            BlockBuffered(w) => w.write_fmt(args),
+            LineBuffered(w) => w.write_fmt(args),
+        }
     }
 }
 

src/libstd/sys/cloudabi/stdio.rs

@@ -21,6 +21,10 @@ impl Stdout {
     pub fn new() -> io::Result<Stdout> {
         Ok(Stdout(()))
     }
+
+    pub fn is_tty(&self) -> bool {
+        true
+    }
 }
 
 impl io::Write for Stdout {
@@ -60,6 +64,7 @@ pub fn is_ebadf(err: &io::Error) -> bool {
 }
 
 pub const STDIN_BUF_SIZE: usize = crate::sys_common::io::DEFAULT_BUF_SIZE;
+pub const STDOUT_BUF_SIZE: usize = 0;
 
 pub fn panic_output() -> Option<impl io::Write> {
     Stderr::new().ok()

src/libstd/sys/redox/stdio.rs

@@ -21,6 +21,15 @@ impl io::Read for Stdin {
 
 impl Stdout {
     pub fn new() -> io::Result<Stdout> { Ok(Stdout(())) }
+
+    pub fn is_tty(&self) -> bool {
+        if let Ok(fd) = syscall::dup(1, b"termios") {
+            let _ = syscall::close(fd);
+            true
+        } else {
+            false
+        }
+    }
 }
 
 impl io::Write for Stdout {
@@ -58,6 +67,7 @@ pub fn is_ebadf(err: &io::Error) -> bool {
 }
 
 pub const STDIN_BUF_SIZE: usize = crate::sys_common::io::DEFAULT_BUF_SIZE;
+pub const STDOUT_BUF_SIZE: usize = crate::sys_common::io::DEFAULT_BUF_SIZE;
 
 pub fn panic_output() -> Option<impl io::Write> {
     Stderr::new().ok()

src/libstd/sys/sgx/stdio.rs

@@ -30,6 +30,11 @@ impl io::Read for Stdin {
 
 impl Stdout {
     pub fn new() -> io::Result<Stdout> { Ok(Stdout(())) }
+
+    // FIXME: implement
+    pub fn is_tty(&self) -> bool {
+        true
+    }
 }
 
 impl io::Write for Stdout {
@@ -57,6 +62,7 @@ impl io::Write for Stderr {
 }
 
 pub const STDIN_BUF_SIZE: usize = crate::sys_common::io::DEFAULT_BUF_SIZE;
+pub const STDOUT_BUF_SIZE: usize = crate::sys_common::io::DEFAULT_BUF_SIZE;
 
 pub fn is_ebadf(err: &io::Error) -> bool {
     // FIXME: Rust normally maps Unix EBADF to `Other`

src/libstd/sys/unix/stdio.rs

@@ -22,6 +22,10 @@ impl io::Read for Stdin {
 
 impl Stdout {
     pub fn new() -> io::Result<Stdout> { Ok(Stdout(())) }
+
+    pub fn is_tty(&self) -> bool {
+        unsafe { libc::isatty(libc::STDOUT_FILENO) != 0 }
+    }
 }
 
 impl io::Write for Stdout {
@@ -61,6 +65,7 @@ pub fn is_ebadf(err: &io::Error) -> bool {
 }
 
 pub const STDIN_BUF_SIZE: usize = crate::sys_common::io::DEFAULT_BUF_SIZE;
+pub const STDOUT_BUF_SIZE: usize = crate::sys_common::io::DEFAULT_BUF_SIZE;
 
 pub fn panic_output() -> Option<impl io::Write> {
     Stderr::new().ok()

src/libstd/sys/wasi/stdio.rs

@@ -27,6 +27,11 @@ impl Stdout {
         Ok(Stdout)
     }
 
+    // FIXME: implement?
+    pub fn is_tty(&self) -> bool {
+        true
+    }
+
     pub fn write(&self, data: &[u8]) -> io::Result<usize> {
         self.write_vectored(&[IoSlice::new(data)])
     }
@@ -71,6 +76,7 @@ impl io::Write for Stderr {
 }
 
 pub const STDIN_BUF_SIZE: usize = crate::sys_common::io::DEFAULT_BUF_SIZE;
+pub const STDOUT_BUF_SIZE: usize = 0;
 
 pub fn is_ebadf(err: &io::Error) -> bool {
     err.raw_os_error() == Some(libc::__WASI_EBADF as i32)

src/libstd/sys/wasm/stdio.rs

@@ -21,6 +21,10 @@ impl Stdout {
     pub fn new() -> io::Result<Stdout> {
         Ok(Stdout)
     }
+
+    pub fn is_tty(&self) -> bool {
+        true
+    }
 }
 
 impl io::Write for Stdout {
@@ -52,6 +56,7 @@ impl io::Write for Stderr {
 }
 
 pub const STDIN_BUF_SIZE: usize = 0;
+pub const STDOUT_BUF_SIZE: usize = 0;
 
 pub fn is_ebadf(_err: &io::Error) -> bool {
     true

src/libstd/sys/windows/c.rs

@@ -124,7 +124,7 @@ pub struct WIN32_FIND_DATAW {
     pub nFileSizeLow: DWORD,
     pub dwReserved0: DWORD,
     pub dwReserved1: DWORD,
-    pub cFileName: [wchar_t; 260], // #define MAX_PATH 260
+    pub cFileName: [wchar_t; MAX_PATH],
     pub cAlternateFileName: [wchar_t; 14],
 }
 impl Clone for WIN32_FIND_DATAW {
@@ -168,6 +168,8 @@ pub const STD_INPUT_HANDLE: DWORD = -10i32 as DWORD;
 pub const STD_OUTPUT_HANDLE: DWORD = -11i32 as DWORD;
 pub const STD_ERROR_HANDLE: DWORD = -12i32 as DWORD;
 
+pub const MAX_PATH: usize = 260;
+
 pub const HANDLE_FLAG_INHERIT: DWORD = 0x00000001;
 
 pub const PROGRESS_CONTINUE: DWORD = 0;
@@ -424,6 +426,12 @@ pub struct FILE_END_OF_FILE_INFO {
     pub EndOfFile: LARGE_INTEGER,
 }
 
+#[repr(C)]
+pub struct FILE_NAME_INFO {
+    pub FileNameLength: DWORD,
+    pub FileName: [WCHAR; 1],
+}
+
 #[repr(C)]
 pub struct REPARSE_DATA_BUFFER {
     pub ReparseTag: c_uint,
@@ -1048,6 +1056,11 @@ extern "system" {
     pub fn GetFileInformationByHandle(hFile: HANDLE,
                             lpFileInformation: LPBY_HANDLE_FILE_INFORMATION)
                             -> BOOL;
+    pub fn GetFileInformationByHandleEx(hFile: HANDLE,
+                            FileInformationClass: FILE_INFO_BY_HANDLE_CLASS,
+                            lpFileInformation: LPVOID,
+                            dwBufferSize: DWORD)
+                            -> BOOL;
 
     pub fn SetLastError(dwErrCode: DWORD);
     pub fn GetCommandLineW() -> *mut LPCWSTR;

src/libstd/sys/windows/stdio.rs

@@ -246,6 +246,10 @@ impl Stdout {
     pub fn new() -> io::Result<Stdout> {
         Ok(Stdout)
     }
+
+    pub fn is_tty(&self) -> bool {
+        is_tty(Stream::Stdout)
+    }
 }
 
 impl io::Write for Stdout {
@@ -281,3 +285,80 @@ pub fn is_ebadf(err: &io::Error) -> bool {
 pub fn panic_output() -> Option<impl io::Write> {
     Stderr::new().ok()
 }
+
+// NOTE: the following has been taken from the atty crate and modified to work with libstd
+
+enum Stream {
+    Stdout,
+    Stderr,
+    Stdin,
+}
+
+fn is_tty(stream: Stream) -> bool {
+    let (fd, others) = match stream {
+        Stream::Stdin => (c::STD_INPUT_HANDLE, [c::STD_ERROR_HANDLE, c::STD_OUTPUT_HANDLE]),
+        Stream::Stderr => (c::STD_ERROR_HANDLE, [c::STD_INPUT_HANDLE, c::STD_OUTPUT_HANDLE]),
+        Stream::Stdout => (c::STD_OUTPUT_HANDLE, [c::STD_INPUT_HANDLE, c::STD_ERROR_HANDLE]),
+    };
+    if unsafe { console_on_any(&[fd]) } {
+        // False positives aren't possible. If we got a console then
+        // we definitely have a tty on stdin.
+        return true;
+    }
+
+    // At this point, we *could* have a false negative. We can determine that
+    // this is true negative if we can detect the presence of a console on
+    // any of the other streams. If another stream has a console, then we know
+    // we're in a Windows console and can therefore trust the negative.
+    if unsafe { console_on_any(&others) } {
+        return false;
+    }
+
+    // Otherwise, we fall back to a very strange msys hack to see if we can
+    // sneakily detect the presence of a tty.
+    unsafe { msys_tty_on(fd) }
+}
+
+/// Returns true if any of the given fds are on a console.
+unsafe fn console_on_any(fds: &[c::DWORD]) -> bool {
+    for &fd in fds {
+        let mut out = 0;
+        let handle = c::GetStdHandle(fd);
+        if c::GetConsoleMode(handle, &mut out) != 0 {
+            return true;
+        }
+    }
+    false
+}
+
+/// Returns true if there is an MSYS tty on the given handle.
+unsafe fn msys_tty_on(fd: c::DWORD) -> bool {
+    use std::mem;
+    use std::slice;
+    use libc::c_void;
+
+    let size = mem::size_of::<c::FILE_NAME_INFO>();
+    let mut name_info_bytes = vec![0u8; size + c::MAX_PATH * mem::size_of::<c::WCHAR>()];
+    let res = c::GetFileInformationByHandleEx(
+        c::GetStdHandle(fd),
+        c::FileNameInfo,
+        &mut *name_info_bytes as *mut _ as *mut c_void,
+        name_info_bytes.len() as u32,
+    );
+    if res == 0 {
+        return false;
+    }
+    let name_info: &c::FILE_NAME_INFO = &*(name_info_bytes.as_ptr() as *const c::FILE_NAME_INFO);
+    let s = slice::from_raw_parts(
+        name_info.FileName.as_ptr(),
+        name_info.FileNameLength as usize / 2,
+    );
+    let name = String::from_utf16_lossy(s);
+    // This checks whether 'pty' exists in the file name, which indicates that
+    // a pseudo-terminal is attached. To mitigate against false positives
+    // (e.g., an actual file name that contains 'pty'), we also require that
+    // either the strings 'msys-' or 'cygwin-' are in the file name as well.)
+    let is_msys = name.contains("msys-") || name.contains("cygwin-");
+    let is_pty = name.contains("-pty");
+    is_msys && is_pty
+}