Replace unsafe static variables with thread-local storage, but still require cargo test -- --test-threads=1.

Author: fxdmhtt

.github/workflows/rust.yml

@@ -25,4 +25,4 @@ jobs:
     - name: Build
       run: cargo build --verbose
     - name: Run tests
-      run: cargo test --verbose
+      run: cargo test --verbose -- --test-threads=1

macros/tests/dep.rs

@@ -1,51 +1,55 @@
 #![allow(static_mut_refs)]
 
+use std::cell::Cell;
+
 use cache::Observable as _;
 use macros::{memo, signal};
 
-static mut SOURCE_A_CALLED: bool = false;
-static mut SOURCE_B_CALLED: bool = false;
-static mut SOURCE_C_CALLED: bool = false;
-static mut SOURCE_D_CALLED: bool = false;
-static mut SOURCE_E_CALLED: bool = false;
+thread_local! {
+    static SOURCE_A_CALLED: Cell<bool> = const { Cell::new(false) };
+    static SOURCE_B_CALLED: Cell<bool> = const { Cell::new(false) };
+    static SOURCE_C_CALLED: Cell<bool> = const { Cell::new(false) };
+    static SOURCE_D_CALLED: Cell<bool> = const { Cell::new(false) };
+    static SOURCE_E_CALLED: Cell<bool> = const { Cell::new(false) };
 
-static mut A: i32 = 10;
-static mut B: i32 = 5;
+    static A: Cell<i32> = const { Cell::new(10) };
+    static B: Cell<i32> = const { Cell::new(5) };
+}
 
 #[signal]
 pub fn source_a() -> i32 {
-    unsafe { SOURCE_A_CALLED = true };
+    SOURCE_A_CALLED.set(true);
 
-    unsafe { A }
+    A.get()
 }
 
 #[signal]
 pub fn source_b() -> i32 {
-    unsafe { SOURCE_B_CALLED = true };
+    SOURCE_B_CALLED.set(true);
 
-    unsafe { B }
+    B.get()
 }
 
 #[memo]
 pub fn derived_c() -> i32 {
-    assert!(!unsafe { SOURCE_C_CALLED });
-    unsafe { SOURCE_C_CALLED = true };
+    assert!(!SOURCE_C_CALLED.get());
+    SOURCE_C_CALLED.set(true);
 
     source_a() + source_b()
 }
 
 #[memo]
 pub fn derived_d() -> i32 {
-    assert!(!unsafe { SOURCE_D_CALLED });
-    unsafe { SOURCE_D_CALLED = true };
+    assert!(!SOURCE_D_CALLED.get());
+    SOURCE_D_CALLED.set(true);
 
     derived_c() * 2
 }
 
 #[memo]
 pub fn derived_e() -> i32 {
-    assert!(!unsafe { SOURCE_E_CALLED });
-    unsafe { SOURCE_E_CALLED = true };
+    assert!(!SOURCE_E_CALLED.get());
+    SOURCE_E_CALLED.set(true);
 
     source_b() - 3
 }
@@ -58,78 +62,78 @@ pub fn derived_e() -> i32 {
 
 #[test]
 fn complex_dependency_memo_test() {
-    unsafe { SOURCE_A_CALLED = false };
-    unsafe { SOURCE_B_CALLED = false };
-    unsafe { SOURCE_C_CALLED = false };
-    unsafe { SOURCE_D_CALLED = false };
-    unsafe { SOURCE_E_CALLED = false };
+    SOURCE_A_CALLED.set(false);
+    SOURCE_B_CALLED.set(false);
+    SOURCE_C_CALLED.set(false);
+    SOURCE_D_CALLED.set(false);
+    SOURCE_E_CALLED.set(false);
 
     let e1 = derived_e();
-    assert!(!unsafe { SOURCE_A_CALLED });
-    assert!(unsafe { SOURCE_B_CALLED });
-    assert!(!unsafe { SOURCE_C_CALLED });
-    assert!(!unsafe { SOURCE_D_CALLED });
-    assert!(unsafe { SOURCE_E_CALLED });
+    assert!(!SOURCE_A_CALLED.get());
+    assert!(SOURCE_B_CALLED.get());
+    assert!(!SOURCE_C_CALLED.get());
+    assert!(!SOURCE_D_CALLED.get());
+    assert!(SOURCE_E_CALLED.get());
     let d1 = derived_d();
-    assert!(unsafe { SOURCE_A_CALLED });
-    assert!(unsafe { SOURCE_B_CALLED });
-    assert!(unsafe { SOURCE_C_CALLED });
-    assert!(unsafe { SOURCE_D_CALLED });
-    assert!(unsafe { SOURCE_E_CALLED });
+    assert!(SOURCE_A_CALLED.get());
+    assert!(SOURCE_B_CALLED.get());
+    assert!(SOURCE_C_CALLED.get());
+    assert!(SOURCE_D_CALLED.get());
+    assert!(SOURCE_E_CALLED.get());
     let c1 = derived_c();
 
     assert_eq!(c1, 15); // 10 + 5
     assert_eq!(d1, 30); // 15 * 2
     assert_eq!(e1, 2); // 5 - 3
 
-    unsafe { A = 10 };
+    A.set(10);
 
-    unsafe { SOURCE_A_CALLED = false };
-    unsafe { SOURCE_B_CALLED = false };
-    unsafe { SOURCE_C_CALLED = false };
-    unsafe { SOURCE_D_CALLED = false };
-    unsafe { SOURCE_E_CALLED = false };
+    SOURCE_A_CALLED.set(false);
+    SOURCE_B_CALLED.set(false);
+    SOURCE_C_CALLED.set(false);
+    SOURCE_D_CALLED.set(false);
+    SOURCE_E_CALLED.set(false);
 
     let e2 = derived_e();
     let d2 = derived_d();
     let c2 = derived_c();
 
-    assert!(!unsafe { SOURCE_A_CALLED });
-    assert!(!unsafe { SOURCE_B_CALLED });
-    assert!(!unsafe { SOURCE_C_CALLED });
-    assert!(!unsafe { SOURCE_D_CALLED });
-    assert!(!unsafe { SOURCE_E_CALLED });
+    assert!(!SOURCE_A_CALLED.get());
+    assert!(!SOURCE_B_CALLED.get());
+    assert!(!SOURCE_C_CALLED.get());
+    assert!(!SOURCE_D_CALLED.get());
+    assert!(!SOURCE_E_CALLED.get());
 
     assert_eq!(c2, c1);
     assert_eq!(d2, d1);
     assert_eq!(e2, e1);
 
     unsafe { SOURCE_A.invalidate() };
 
-    unsafe { SOURCE_A_CALLED = false };
-    unsafe { SOURCE_B_CALLED = false };
-    unsafe { SOURCE_C_CALLED = false };
-    unsafe { SOURCE_D_CALLED = false };
-    unsafe { SOURCE_E_CALLED = false };
+    SOURCE_A_CALLED.set(false);
+    SOURCE_B_CALLED.set(false);
+    SOURCE_C_CALLED.set(false);
+    SOURCE_D_CALLED.set(false);
+    SOURCE_E_CALLED.set(false);
 
     let e3 = derived_e();
-    assert!(!unsafe { SOURCE_A_CALLED });
-    assert!(!unsafe { SOURCE_B_CALLED });
-    assert!(!unsafe { SOURCE_C_CALLED });
-    assert!(!unsafe { SOURCE_D_CALLED });
-    assert!(!unsafe { SOURCE_E_CALLED });
+    assert!(!SOURCE_A_CALLED.get());
+    assert!(!SOURCE_B_CALLED.get());
+    assert!(!SOURCE_C_CALLED.get());
+    assert!(!SOURCE_D_CALLED.get());
+    assert!(!SOURCE_E_CALLED.get());
     let d3 = derived_d();
-    assert!(unsafe { SOURCE_A_CALLED });
-    assert!(unsafe { SOURCE_B_CALLED });
-    assert!(unsafe { SOURCE_C_CALLED });
-    assert!(unsafe { SOURCE_D_CALLED });
-    assert!(!unsafe { SOURCE_E_CALLED });
+    assert!(SOURCE_A_CALLED.get());
+    assert!(SOURCE_B_CALLED.get());
+    assert!(SOURCE_C_CALLED.get());
+    assert!(SOURCE_D_CALLED.get());
+    assert!(!SOURCE_E_CALLED.get());
     let c3 = derived_c();
-    assert!(unsafe { SOURCE_A_CALLED });
-    assert!(unsafe { SOURCE_B_CALLED });
-    assert!(unsafe { SOURCE_C_CALLED });
-    assert!(unsafe { SOURCE_D_CALLED });
-    assert!(!unsafe { SOURCE_E_CALLED });
+    assert!(SOURCE_A_CALLED.get());
+    assert!(SOURCE_B_CALLED.get());
+    assert!(SOURCE_C_CALLED.get());
+    assert!(SOURCE_D_CALLED.get());
+    assert!(!SOURCE_E_CALLED.get());
 
     assert_eq!(c3, 15);
     assert_eq!(d3, 30);
@@ -138,11 +142,11 @@ fn complex_dependency_memo_test() {
 
 #[test]
 fn signal_set_unchanged_test() {
-    unsafe { SOURCE_A_CALLED = false };
-    unsafe { SOURCE_B_CALLED = false };
-    unsafe { SOURCE_C_CALLED = false };
-    unsafe { SOURCE_D_CALLED = false };
-    unsafe { SOURCE_E_CALLED = false };
+    SOURCE_A_CALLED.set(false);
+    SOURCE_B_CALLED.set(false);
+    SOURCE_C_CALLED.set(false);
+    SOURCE_D_CALLED.set(false);
+    SOURCE_E_CALLED.set(false);
 
     let e1 = derived_e();
     let d1 = derived_d();
@@ -154,21 +158,21 @@ fn signal_set_unchanged_test() {
 
     unsafe { SOURCE_A.set(10) };
 
-    unsafe { SOURCE_A_CALLED = false };
-    unsafe { SOURCE_B_CALLED = false };
-    unsafe { SOURCE_C_CALLED = false };
-    unsafe { SOURCE_D_CALLED = false };
-    unsafe { SOURCE_E_CALLED = false };
+    SOURCE_A_CALLED.set(false);
+    SOURCE_B_CALLED.set(false);
+    SOURCE_C_CALLED.set(false);
+    SOURCE_D_CALLED.set(false);
+    SOURCE_E_CALLED.set(false);
 
     let e2 = derived_e();
     let d2 = derived_d();
     let c2 = derived_c();
 
-    assert!(!unsafe { SOURCE_A_CALLED });
-    assert!(!unsafe { SOURCE_B_CALLED });
-    assert!(!unsafe { SOURCE_C_CALLED });
-    assert!(!unsafe { SOURCE_D_CALLED });
-    assert!(!unsafe { SOURCE_E_CALLED });
+    assert!(!SOURCE_A_CALLED.get());
+    assert!(!SOURCE_B_CALLED.get());
+    assert!(!SOURCE_C_CALLED.get());
+    assert!(!SOURCE_D_CALLED.get());
+    assert!(!SOURCE_E_CALLED.get());
 
     assert_eq!(c2, c1);
     assert_eq!(d2, d1);
@@ -177,11 +181,11 @@ fn signal_set_unchanged_test() {
 
 #[test]
 fn signal_set_value_test() {
-    unsafe { SOURCE_A_CALLED = false };
-    unsafe { SOURCE_B_CALLED = false };
-    unsafe { SOURCE_C_CALLED = false };
-    unsafe { SOURCE_D_CALLED = false };
-    unsafe { SOURCE_E_CALLED = false };
+    SOURCE_A_CALLED.set(false);
+    SOURCE_B_CALLED.set(false);
+    SOURCE_C_CALLED.set(false);
+    SOURCE_D_CALLED.set(false);
+    SOURCE_E_CALLED.set(false);
 
     let e1 = derived_e();
     let d1 = derived_d();
@@ -193,30 +197,30 @@ fn signal_set_value_test() {
 
     unsafe { SOURCE_A.set(20) };
 
-    unsafe { SOURCE_A_CALLED = false };
-    unsafe { SOURCE_B_CALLED = false };
-    unsafe { SOURCE_C_CALLED = false };
-    unsafe { SOURCE_D_CALLED = false };
-    unsafe { SOURCE_E_CALLED = false };
+    SOURCE_A_CALLED.set(false);
+    SOURCE_B_CALLED.set(false);
+    SOURCE_C_CALLED.set(false);
+    SOURCE_D_CALLED.set(false);
+    SOURCE_E_CALLED.set(false);
 
     let e2 = derived_e();
-    assert!(!unsafe { SOURCE_A_CALLED });
-    assert!(!unsafe { SOURCE_B_CALLED });
-    assert!(!unsafe { SOURCE_C_CALLED });
-    assert!(!unsafe { SOURCE_D_CALLED });
-    assert!(!unsafe { SOURCE_E_CALLED });
+    assert!(!SOURCE_A_CALLED.get());
+    assert!(!SOURCE_B_CALLED.get());
+    assert!(!SOURCE_C_CALLED.get());
+    assert!(!SOURCE_D_CALLED.get());
+    assert!(!SOURCE_E_CALLED.get());
     let d2 = derived_d();
-    assert!(unsafe { SOURCE_A_CALLED });
-    assert!(unsafe { SOURCE_B_CALLED });
-    assert!(unsafe { SOURCE_C_CALLED });
-    assert!(unsafe { SOURCE_D_CALLED });
-    assert!(!unsafe { SOURCE_E_CALLED });
+    assert!(SOURCE_A_CALLED.get());
+    assert!(SOURCE_B_CALLED.get());
+    assert!(SOURCE_C_CALLED.get());
+    assert!(SOURCE_D_CALLED.get());
+    assert!(!SOURCE_E_CALLED.get());
     let c2 = derived_c();
-    assert!(unsafe { SOURCE_A_CALLED });
-    assert!(unsafe { SOURCE_B_CALLED });
-    assert!(unsafe { SOURCE_C_CALLED });
-    assert!(unsafe { SOURCE_D_CALLED });
-    assert!(!unsafe { SOURCE_E_CALLED });
+    assert!(SOURCE_A_CALLED.get());
+    assert!(SOURCE_B_CALLED.get());
+    assert!(SOURCE_C_CALLED.get());
+    assert!(SOURCE_D_CALLED.get());
+    assert!(!SOURCE_E_CALLED.get());
 
     assert_eq!(c2, c1);
     assert_eq!(d2, d1);