io/os: Implement IsTerminal trait on Stdio

library/std/src/io/mod.rs

@@ -266,6 +266,8 @@ pub use self::buffered::WriterPanicked;
 #[unstable(feature = "internal_output_capture", issue = "none")]
 #[doc(no_inline, hidden)]
 pub use self::stdio::set_output_capture;
+#[unstable(feature = "is_terminal", issue = "80937")]
+pub use self::stdio::IsTerminal;
 #[unstable(feature = "print_internals", issue = "none")]
 pub use self::stdio::{_eprint, _print};
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -2379,7 +2381,11 @@ impl<T: BufRead, U: BufRead> BufRead for Chain<T, U> {
     }
 
     fn consume(&mut self, amt: usize) {
-        if !self.done_first { self.first.consume(amt) } else { self.second.consume(amt) }
+        if !self.done_first {
+            self.first.consume(amt)
+        } else {
+            self.second.consume(amt)
+        }
     }
 }
 

library/std/src/io/stdio.rs

@@ -1018,6 +1018,59 @@ where
     }
 }
 
+/// Trait to determine if stdio stream (Stdin, Stdout, Stderr) is a terminal/tty.
+#[unstable(feature = "is_terminal", issue = "80937")]
+pub trait IsTerminal {
+    /// returns true if stdio stream (Stdin, Stdout, Stderr) is a terminal/tty.
+    fn is_terminal() -> bool;
+}
+
+cfg_if::cfg_if! {
+    if #[cfg(any(unix, windows))] {
+        #[unstable(feature = "is_terminal", issue = "80937")]
+        impl IsTerminal for Stdin {
+            fn is_terminal() -> bool {
+               stdio::Stdin::is_terminal()
+            }
+        }
+
+        #[unstable(feature = "is_terminal", issue = "80937")]
+        impl IsTerminal for Stdout {
+            fn is_terminal() -> bool {
+                stdio::Stdout::is_terminal()
+            }
+        }
+
+        #[unstable(feature = "is_terminal", issue = "80937")]
+        impl IsTerminal for Stderr {
+            fn is_terminal() -> bool {
+                stdio::Stderr::is_terminal()
+            }
+        }
+    } else {
+        #[unstable(feature = "is_terminal", issue = "80937")]
+        impl IsTerminal for Stdin {
+            fn is_terminal() -> bool {
+                false
+            }
+        }
+
+        #[unstable(feature = "is_terminal", issue = "80937")]
+        impl IsTerminal for Stdout {
+            fn is_terminal() -> bool {
+                false
+            }
+        }
+
+        #[unstable(feature = "is_terminal", issue = "80937")]
+        impl IsTerminal for Stderr {
+            fn is_terminal() -> bool {
+                false
+            }
+        }
+    }
+}
+
 #[unstable(
     feature = "print_internals",
     reason = "implementation detail which may disappear or be replaced at any time",

library/std/src/lib.rs

@@ -279,6 +279,7 @@
 #![feature(hashmap_internals)]
 #![feature(int_error_internals)]
 #![feature(intra_doc_pointers)]
+#![feature(is_terminal)]
 #![feature(lang_items)]
 #![feature(linkage)]
 #![feature(log_syntax)]

library/std/src/sys/hermit/stdio.rs

@@ -118,3 +118,23 @@ pub fn is_ebadf(_err: &io::Error) -> bool {
 pub fn panic_output() -> Option<impl io::Write> {
     Some(Stderr::new())
 }
+
+#[unstable(feature = "is_terminal", issue = "80937")]
+impl io::IsTerminal for sys::stdio::Stdin {
+    fn is_terminal() -> bool {
+        abi::isatty(abi::STDIN_FILENO)
+    }
+}
+
+#[unstable(feature = "is_terminal", issue = "80937")]
+impl io::IsTerminal for sys::stdio::Stdout {
+    fn is_terminal() -> bool {
+        abi::isatty(abi::STDOUT_FILENO)
+    }
+}
+#[unstable(feature = "is_terminal", issue = "80937")]
+impl io::IsTerminal for sys::stdio::Stderr {
+    fn is_terminal() -> bool {
+        abi::isatty(abi::STDERR_FILENO)
+    }
+}

library/std/src/sys/unix/io.rs

@@ -1,6 +1,7 @@
+use crate::io;
 use crate::marker::PhantomData;
 use crate::slice;
-
+use crate::sys;
 use libc::{c_void, iovec};
 
 #[derive(Copy, Clone)]
@@ -74,3 +75,23 @@ impl<'a> IoSliceMut<'a> {
         unsafe { slice::from_raw_parts_mut(self.vec.iov_base as *mut u8, self.vec.iov_len) }
     }
 }
+
+#[unstable(feature = "is_terminal", issue = "80937")]
+impl io::IsTerminal for sys::stdio::Stdin {
+    fn is_terminal() -> bool {
+        unsafe { libc::isatty(libc::STDIN_FILENO) != 0 }
+    }
+}
+
+#[unstable(feature = "is_terminal", issue = "80937")]
+impl io::IsTerminal for sys::stdio::Stdout {
+    fn is_terminal() -> bool {
+        unsafe { libc::isatty(libc::STDOUT_FILENO) != 0 }
+    }
+}
+#[unstable(feature = "is_terminal", issue = "80937")]
+impl io::IsTerminal for sys::stdio::Stderr {
+    fn is_terminal() -> bool {
+        unsafe { libc::isatty(libc::STDERR_FILENO) != 0 }
+    }
+}

library/std/src/sys/windows/c.rs

@@ -124,6 +124,8 @@ pub const SECURITY_SQOS_PRESENT: DWORD = 0x00100000;
 
 pub const FIONBIO: c_ulong = 0x8004667e;
 
+pub const MAX_PATH: usize = 260;
+
 #[repr(C)]
 #[derive(Copy)]
 pub struct WIN32_FIND_DATAW {
@@ -484,6 +486,12 @@ pub struct SYMBOLIC_LINK_REPARSE_BUFFER {
     pub PathBuffer: WCHAR,
 }
 
+#[repr(C)]
+pub struct FILE_NAME_INFO {
+    pub FileNameLength: DWORD,
+    pub FileName: [WCHAR; 1],
+}
+
 #[repr(C)]
 pub struct MOUNT_POINT_REPARSE_BUFFER {
     pub SubstituteNameOffset: c_ushort,

library/std/src/sys/windows/io.rs

@@ -1,6 +1,10 @@
+use crate::io;
 use crate::marker::PhantomData;
 use crate::slice;
+use crate::sys;
 use crate::sys::c;
+use core;
+use libc;
 
 #[derive(Copy, Clone)]
 #[repr(transparent)]
@@ -78,3 +82,120 @@ impl<'a> IoSliceMut<'a> {
         unsafe { slice::from_raw_parts_mut(self.vec.buf as *mut u8, self.vec.len as usize) }
     }
 }
+
+#[unstable(feature = "is_terminal", issue = "80937")]
+impl io::IsTerminal for sys::stdio::Stdin {
+    fn is_terminal() -> bool {
+        let fd = c::STD_INPUT_HANDLE;
+        let others = [c::STD_ERROR_HANDLE, c::STD_OUTPUT_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) }
+    }
+}
+
+#[unstable(feature = "is_terminal", issue = "80937")]
+impl io::IsTerminal for sys::stdio::Stdout {
+    fn is_terminal() -> bool {
+        let fd = c::STD_OUTPUT_HANDLE;
+        let others = [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 stdout.
+            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) }
+    }
+}
+
+#[unstable(feature = "is_terminal", issue = "80937")]
+impl io::IsTerminal for sys::stdio::Stderr {
+    fn is_terminal() -> bool {
+        let fd = c::STD_ERROR_HANDLE;
+        let others = [c::STD_INPUT_HANDLE, c::STD_OUTPUT_HANDLE];
+
+        if unsafe { console_on_any(&[fd]) } {
+            // False positives aren't possible. If we got a console then
+            // we definitely have a tty on stderr.
+            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) }
+    }
+}
+
+#[unstable(feature = "is_terminal", issue = "80937")]
+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
+}
+#[unstable(feature = "is_terminal", issue = "80937")]
+unsafe fn msys_tty_on(fd: c::DWORD) -> bool {
+    let size = core::mem::size_of::<c::FILE_NAME_INFO>();
+    let mut name_info_bytes = vec![0u8; size + c::MAX_PATH * core::mem::size_of::<c::WCHAR>()];
+    let res = c::GetFileInformationByHandleEx(
+        c::GetStdHandle(fd),
+        c::FileNameInfo,
+        &mut *name_info_bytes as *mut _ as *mut libc::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 = core::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
+}

library/test/src/cli.rs

@@ -3,9 +3,9 @@
 use std::env;
 use std::path::PathBuf;
 
-use super::helpers::isatty;
 use super::options::{ColorConfig, Options, OutputFormat, RunIgnored};
 use super::time::TestTimeOptions;
+use std::io::{IsTerminal, Stdout};
 
 #[derive(Debug)]
 pub struct TestOpts {
@@ -32,7 +32,7 @@ pub struct TestOpts {
 impl TestOpts {
     pub fn use_color(&self) -> bool {
         match self.color {
-            ColorConfig::AutoColor => !self.nocapture && isatty::stdout_isatty(),
+            ColorConfig::AutoColor => !self.nocapture && Stdout::is_terminal(),
             ColorConfig::AlwaysColor => true,
             ColorConfig::NeverColor => false,
         }

library/test/src/helpers/mod.rs

@@ -3,6 +3,5 @@
 
 pub mod concurrency;
 pub mod exit_code;
-pub mod isatty;
 pub mod metrics;
 pub mod shuffle;

library/test/src/lib.rs

@@ -18,6 +18,8 @@
 #![feature(nll)]
 #![feature(bench_black_box)]
 #![feature(internal_output_capture)]
+#![feature(is_terminal)]
+#![feature(panic_unwind)]
 #![feature(staged_api)]
 #![feature(termination_trait_lib)]
 #![feature(process_exitcode_placeholder)]
@@ -292,7 +294,11 @@ where
     fn calc_timeout(timeout_queue: &VecDeque<TimeoutEntry>) -> Option<Duration> {
         timeout_queue.front().map(|&TimeoutEntry { timeout: next_timeout, .. }| {
             let now = Instant::now();
-            if next_timeout >= now { next_timeout - now } else { Duration::new(0, 0) }
+            if next_timeout >= now {
+                next_timeout - now
+            } else {
+                Duration::new(0, 0)
+            }
         })
     }