Cache whether RUST_BACKTRACE is enabled in a relaxed atomic static.

Author: eddyb

CHANGELOG.md

@@ -1,6 +1,7 @@
 # Unreleased
 
 - Change last rust version supported to 1.14
+- [Cache whether RUST_BACKTRACE is enabled in a relaxed atomic static.](https://github.com/rust-lang-nursery/error-chain/pull/210)
 
 # 0.11.0-rc.2
 

src/bin/has_backtrace.rs

@@ -0,0 +1,18 @@
+//! Exits with exit code 0 if backtraces are disabled and 1 if they are enabled.
+//! Used by tests to make sure backtraces are available when they should be. Should not be used
+//! outside of the tests.
+
+#[macro_use]
+extern crate error_chain;
+
+error_chain! {
+    errors {
+        MyError
+    }
+}
+
+fn main() {
+    let err = Error::from(ErrorKind::MyError);
+    let has_backtrace = err.backtrace().is_some();
+    ::std::process::exit(has_backtrace as i32);
+}

src/lib.rs

@@ -593,9 +593,29 @@ impl<'a> Iterator for Iter<'a> {
 #[cfg(feature = "backtrace")]
 #[doc(hidden)]
 pub fn make_backtrace() -> Option<Arc<Backtrace>> {
-    match std::env::var_os("RUST_BACKTRACE") {
-        Some(ref val) if val != "0" => Some(Arc::new(Backtrace::new())),
-        _ => None,
+    use std::sync::atomic::{ATOMIC_USIZE_INIT, AtomicUsize, Ordering};
+
+    // The lowest bit indicates whether the value was computed,
+    // while the second lowest bit is the actual "enabled" bit.
+    static BACKTRACE_ENABLED_CACHE: AtomicUsize = ATOMIC_USIZE_INIT;
+
+    let enabled = match BACKTRACE_ENABLED_CACHE.load(Ordering::Relaxed) {
+        0 => {
+            let enabled = match std::env::var_os("RUST_BACKTRACE") {
+                Some(ref val) if val != "0" => true,
+                _ => false
+            };
+            let encoded = ((enabled as usize) << 1) | 1;
+            BACKTRACE_ENABLED_CACHE.store(encoded, Ordering::Relaxed);
+            enabled
+        }
+        encoded => (encoded >> 1) != 0
+    };
+
+    if enabled {
+        Some(Arc::new(Backtrace::new()))
+    } else {
+        None
     }
 }
 

tests/tests.rs

@@ -200,35 +200,29 @@ fn empty() {
 #[test]
 #[cfg(feature = "backtrace")]
 fn has_backtrace_depending_on_env() {
-    use std::env;
+    use std::process::Command;
+    use std::path::Path;
 
-    error_chain! {
-        types {}
-        links {}
-        foreign_links {}
-        errors {
-            MyError
-        }
-    }
-
-    let original_value = env::var_os("RUST_BACKTRACE");
+    let cmd_path = if cfg!(windows) {
+        Path::new("./target/debug/has_backtrace.exe")
+    } else {
+        Path::new("./target/debug/has_backtrace")
+    };
+    let mut cmd = Command::new(cmd_path);
 
     // missing RUST_BACKTRACE and RUST_BACKTRACE=0
-    env::remove_var("RUST_BACKTRACE");
-    let err = Error::from(ErrorKind::MyError);
-    assert!(err.backtrace().is_none());
-    env::set_var("RUST_BACKTRACE", "0");
-    let err = Error::from(ErrorKind::MyError);
-    assert!(err.backtrace().is_none());
+    cmd.env_remove("RUST_BACKTRACE");
+    assert_eq!(cmd.status().unwrap().code().unwrap(), 0);
+
+    cmd.env("RUST_BACKTRACE", "0");
+    assert_eq!(cmd.status().unwrap().code().unwrap(), 0);
 
     // RUST_BACKTRACE set to anything but 0
-    env::set_var("RUST_BACKTRACE", "yes");
-    let err = Error::from(ErrorKind::MyError);
-    assert!(err.backtrace().is_some());
+    cmd.env("RUST_BACKTRACE", "yes");
+    assert_eq!(cmd.status().unwrap().code().unwrap(), 1);
 
-    if let Some(var) = original_value {
-        env::set_var("RUST_BACKTRACE", var);
-    }
+    cmd.env("RUST_BACKTRACE", "1");
+    assert_eq!(cmd.status().unwrap().code().unwrap(), 1);
 }
 
 #[test]