Refactor stderr_prints_nothing into a more meaningful type

Author: Jethro Beekman

src/libstd/panicking.rs

@@ -29,12 +29,26 @@ use intrinsics;
 use mem;
 use ptr;
 use raw;
-use sys::stdio::{Stderr, stderr_prints_nothing};
+use sys::stdio::{Stderr, panic_output};
 use sys_common::rwlock::RWLock;
 use sys_common::thread_info;
 use sys_common::util;
 use thread;
 
+#[derive(Clone, Copy)]
+#[allow(dead_code)]
+pub enum PanicOutput {
+    StdErr,
+}
+
+impl PanicOutput {
+    pub(crate) fn write<T, F: FnOnce(&mut Write) -> T>(self, write: F) {
+        match self {
+            PanicOutput::StdErr => Stderr::new().ok().map(|mut w| write(&mut w)),
+        };
+    }
+}
+
 thread_local! {
     pub static LOCAL_STDERR: RefCell<Option<Box<dyn Write + Send>>> = {
         RefCell::new(None)
@@ -168,6 +182,11 @@ pub fn take_hook() -> Box<dyn Fn(&PanicInfo) + 'static + Sync + Send> {
 }
 
 fn default_hook(info: &PanicInfo) {
+    let out = match panic_output() {
+        Some(out) => out,
+        None => return
+    };
+
     #[cfg(feature = "backtrace")]
     use sys_common::backtrace;
 
@@ -193,7 +212,6 @@ fn default_hook(info: &PanicInfo) {
             None => "Box<Any>",
         }
     };
-    let mut err = Stderr::new().ok();
     let thread = thread_info::current_thread();
     let name = thread.as_ref().and_then(|t| t.name()).unwrap_or("<unnamed>");
 
@@ -215,17 +233,14 @@ fn default_hook(info: &PanicInfo) {
         }
     };
 
-    let prev = LOCAL_STDERR.with(|s| s.borrow_mut().take());
-    match (prev, err.as_mut()) {
-       (Some(mut stderr), _) => {
-           write(&mut *stderr);
-           let mut s = Some(stderr);
-           LOCAL_STDERR.with(|slot| {
-               *slot.borrow_mut() = s.take();
-           });
-       }
-       (None, Some(ref mut err)) => { write(err) }
-       _ => {}
+    if let Some(mut local) = LOCAL_STDERR.with(|s| s.borrow_mut().take()) {
+       write(&mut *local);
+       let mut s = Some(local);
+       LOCAL_STDERR.with(|slot| {
+           *slot.borrow_mut() = s.take();
+       });
+    } else {
+        out.write(write);
     }
 }
 
@@ -466,20 +481,11 @@ fn rust_panic_with_hook(payload: &mut dyn BoxMeUp,
             Location::internal_constructor(file, line, col),
         );
         HOOK_LOCK.read();
+        info.set_payload(payload.get());
         match HOOK {
-            // Some platforms know that printing to stderr won't ever actually
-            // print anything, and if that's the case we can skip the default
-            // hook.
-            Hook::Default if stderr_prints_nothing() => {}
-            Hook::Default => {
-                info.set_payload(payload.get());
-                default_hook(&info);
-            }
-            Hook::Custom(ptr) => {
-                info.set_payload(payload.get());
-                (*ptr)(&info);
-            }
-        }
+            Hook::Default => default_hook(&info),
+            Hook::Custom(ptr) => (*ptr)(&info),
+        };
         HOOK_LOCK.read_unlock();
     }
 

src/libstd/sys/cloudabi/stdio.rs

@@ -10,6 +10,7 @@
 
 use io;
 use sys::cloudabi::abi;
+use panicking::PanicOutput;
 
 pub struct Stdin(());
 pub struct Stdout(());
@@ -78,6 +79,6 @@ pub fn is_ebadf(err: &io::Error) -> bool {
 
 pub const STDIN_BUF_SIZE: usize = ::sys_common::io::DEFAULT_BUF_SIZE;
 
-pub fn stderr_prints_nothing() -> bool {
-    false
+pub fn panic_output() -> Option<PanicOutput> {
+    Some(PanicOutput::StdErr)
 }

src/libstd/sys/redox/stdio.rs

@@ -11,6 +11,7 @@
 use io;
 use sys::{cvt, syscall};
 use sys::fd::FileDesc;
+use panicking::PanicOutput;
 
 pub struct Stdin(());
 pub struct Stdout(());
@@ -76,6 +77,6 @@ pub fn is_ebadf(err: &io::Error) -> bool {
 
 pub const STDIN_BUF_SIZE: usize = ::sys_common::io::DEFAULT_BUF_SIZE;
 
-pub fn stderr_prints_nothing() -> bool {
-    false
+pub fn panic_output() -> Option<PanicOutput> {
+    Some(PanicOutput::StdErr)
 }

src/libstd/sys/unix/stdio.rs

@@ -11,6 +11,7 @@
 use io;
 use libc;
 use sys::fd::FileDesc;
+use panicking::PanicOutput;
 
 pub struct Stdin(());
 pub struct Stdout(());
@@ -76,6 +77,6 @@ pub fn is_ebadf(err: &io::Error) -> bool {
 
 pub const STDIN_BUF_SIZE: usize = ::sys_common::io::DEFAULT_BUF_SIZE;
 
-pub fn stderr_prints_nothing() -> bool {
-    false
+pub fn panic_output() -> Option<PanicOutput> {
+    Some(PanicOutput::StdErr)
 }

src/libstd/sys/wasm/stdio.rs

@@ -10,6 +10,7 @@
 
 use io;
 use sys::{ReadSysCall, WriteSysCall};
+use panicking::PanicOutput;
 
 pub struct Stdin;
 pub struct Stdout;
@@ -70,6 +71,10 @@ pub fn is_ebadf(_err: &io::Error) -> bool {
     true
 }
 
-pub fn stderr_prints_nothing() -> bool {
-    !cfg!(feature = "wasm_syscall")
+pub fn panic_output() -> Option<PanicOutput> {
+    if cfg!(feature = "wasm_syscall") {
+        Some(PanicOutput::StdErr)
+    } else {
+        None
+    }
 }

src/libstd/sys/windows/stdio.rs

@@ -20,6 +20,7 @@ use sync::Mutex;
 use sys::c;
 use sys::cvt;
 use sys::handle::Handle;
+use panicking::PanicOutput;
 
 pub enum Output {
     Console(c::HANDLE),
@@ -228,6 +229,6 @@ pub fn is_ebadf(err: &io::Error) -> bool {
 // been seen to be acceptable.
 pub const STDIN_BUF_SIZE: usize = 8 * 1024;
 
-pub fn stderr_prints_nothing() -> bool {
-    false
+pub fn panic_output() -> Option<PanicOutput> {
+    Some(PanicOutput::StdErr)
 }

src/libstd/sys_common/util.rs

@@ -9,15 +9,11 @@
 // except according to those terms.
 
 use fmt;
-use io::prelude::*;
-use sys::stdio::{Stderr, stderr_prints_nothing};
+use sys::stdio::panic_output;
 use thread;
 
 pub fn dumb_print(args: fmt::Arguments) {
-    if stderr_prints_nothing() {
-        return
-    }
-    let _ = Stderr::new().map(|mut stderr| stderr.write_fmt(args));
+    panic_output().map(|w| w.write(|out| out.write_fmt(args)));
 }
 
 // Other platforms should use the appropriate platform-specific mechanism for