From 8a0dffd366f00fea84d709173e0c27ea83eb8591 Mon Sep 17 00:00:00 2001
From: Jake Goulding <jake.goulding@gmail.com>
Date: Wed, 19 Oct 2022 14:39:10 -0400
Subject: [PATCH] Extract a set-exactly-once boolean value

---
 src/lib.rs       | 26 ++++++++++----------------
 src/once_bool.rs | 27 +++++++++++++++++++++++++++
 2 files changed, 37 insertions(+), 16 deletions(-)
 create mode 100644 src/once_bool.rs

diff --git a/src/lib.rs b/src/lib.rs
index 4f6f9b61..0f0ec81a 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -256,6 +256,9 @@ mod backtrace_shim;
 ))]
 pub use crate::backtrace_shim::*;
 
+#[cfg(any(feature = "std", test))]
+mod once_bool;
+
 #[cfg(feature = "backtraces-impl-backtrace-crate")]
 pub use backtrace::Backtrace;
 
@@ -1216,26 +1219,17 @@ impl AsBacktrace for Option<Backtrace> {
 
 #[cfg(any(feature = "std", test))]
 fn backtrace_collection_enabled() -> bool {
-    use std::{
-        env,
-        sync::{
-            atomic::{AtomicBool, Ordering},
-            Once,
-        },
-    };
+    use crate::once_bool::OnceBool;
+    use std::env;
 
-    static START: Once = Once::new();
-    static ENABLED: AtomicBool = AtomicBool::new(false);
+    static ENABLED: OnceBool = OnceBool::new();
 
-    START.call_once(|| {
+    ENABLED.get(|| {
         // TODO: What values count as "true"?
-        let enabled = env::var_os("RUST_LIB_BACKTRACE")
+        env::var_os("RUST_LIB_BACKTRACE")
             .or_else(|| env::var_os("RUST_BACKTRACE"))
-            .map_or(false, |v| v == "1");
-        ENABLED.store(enabled, Ordering::SeqCst);
-    });
-
-    ENABLED.load(Ordering::SeqCst)
+            .map_or(false, |v| v == "1")
+    })
 }
 
 #[cfg(feature = "backtraces-impl-backtrace-crate")]
diff --git a/src/once_bool.rs b/src/once_bool.rs
new file mode 100644
index 00000000..1a858c84
--- /dev/null
+++ b/src/once_bool.rs
@@ -0,0 +1,27 @@
+use std::sync::{
+    atomic::{AtomicBool, Ordering},
+    Once,
+};
+
+pub struct OnceBool {
+    start: Once,
+    enabled: AtomicBool,
+}
+
+impl OnceBool {
+    pub const fn new() -> Self {
+        Self {
+            start: Once::new(),
+            enabled: AtomicBool::new(false),
+        }
+    }
+
+    pub fn get<F: FnOnce() -> bool>(&self, f: F) -> bool {
+        self.start.call_once(|| {
+            let enabled = f();
+            self.enabled.store(enabled, Ordering::SeqCst);
+        });
+
+        self.enabled.load(Ordering::SeqCst)
+    }
+}