use godot_thread_local instead of thread_local

esrt

Author: PgBiel

godot-core/src/meta/signature.rs

@@ -739,7 +739,7 @@ pub mod trace {
         TRACE.set(Some(report));
     }
 
-    thread_local! {
+    crate::private::godot_thread_local! {
         static TRACE: Cell<Option<CallReport>> = Cell::default();
     }
 }

godot-core/src/private.rs

@@ -320,12 +320,12 @@ pub(crate) fn has_error_print_level(level: u8) -> bool {
 /// Internal type used to store context information for debug purposes. Debug context is stored on the thread-local
 /// ERROR_CONTEXT_STACK, which can later be used to retrieve the current context in the event of a panic. This value
 /// probably shouldn't be used directly; use ['get_gdext_panic_context()'](get_gdext_panic_context) instead.
-#[cfg(all(debug_assertions, not(wasm_nothreads)))]
+#[cfg(debug_assertions)]
 struct ScopedFunctionStack {
     functions: Vec<*const dyn Fn() -> String>,
 }
 
-#[cfg(all(debug_assertions, not(wasm_nothreads)))]
+#[cfg(debug_assertions)]
 impl ScopedFunctionStack {
     /// # Safety
     /// Function must be removed (using [`pop_function()`](Self::pop_function)) before lifetime is invalidated.
@@ -616,19 +616,19 @@ macro_rules! godot_thread_local {
 
 pub(crate) use godot_thread_local;
 
-#[cfg(all(debug_assertions, not(wasm_nothreads)))]
-thread_local! {
+#[cfg(debug_assertions)]
+godot_thread_local! {
     static ERROR_CONTEXT_STACK: RefCell<ScopedFunctionStack> = const {
         RefCell::new(ScopedFunctionStack { functions: Vec::new() })
     }
 }
 
 // Value may return `None`, even from panic hook, if called from a non-Godot thread.
 pub fn get_gdext_panic_context() -> Option<String> {
-    #[cfg(all(debug_assertions, not(wasm_nothreads)))]
+    #[cfg(debug_assertions)]
     return ERROR_CONTEXT_STACK.with(|cell| cell.borrow().get_last());
 
-    #[cfg(not(all(debug_assertions, not(wasm_nothreads))))]
+    #[cfg(not(debug_assertions))]
     None
 }
 
@@ -643,10 +643,10 @@ where
     E: Fn() -> String,
     F: FnOnce() -> R + std::panic::UnwindSafe,
 {
-    #[cfg(not(all(debug_assertions, not(wasm_nothreads))))]
-    let _ = error_context; // Unused in Release or `wasm_nothreads` builds.
+    #[cfg(not(debug_assertions))]
+    let _ = error_context; // Unused in Release.
 
-    #[cfg(all(debug_assertions, not(wasm_nothreads)))]
+    #[cfg(debug_assertions)]
     ERROR_CONTEXT_STACK.with(|cell| unsafe {
         // SAFETY: &error_context is valid for lifetime of function, and is removed from LAST_ERROR_CONTEXT before end of function.
         cell.borrow_mut().push_function(&error_context)
@@ -655,7 +655,7 @@ where
     let result =
         std::panic::catch_unwind(code).map_err(|payload| extract_panic_message(payload.as_ref()));
 
-    #[cfg(all(debug_assertions, not(wasm_nothreads)))]
+    #[cfg(debug_assertions)]
     ERROR_CONTEXT_STACK.with(|cell| cell.borrow_mut().pop_function());
     result
 }

godot-core/src/task/async_runtime.rs

@@ -12,7 +12,7 @@ use std::panic::AssertUnwindSafe;
 use std::pin::Pin;
 use std::sync::Arc;
 use std::task::{Context, Poll, Wake, Waker};
-use std::thread::{self, LocalKey, ThreadId};
+use std::thread::{self, ThreadId};
 
 use crate::builtin::{Callable, Variant};
 use crate::private::handle_panic;
@@ -147,7 +147,7 @@ impl TaskHandle {
 
 const ASYNC_RUNTIME_DEINIT_PANIC_MESSAGE: &str = "The async runtime is being accessed after it has been deinitialized. This should not be possible and is most likely a bug.";
 
-thread_local! {
+crate::private::godot_thread_local! {
     /// The thread local is only initialized the first time it's used. This means the async runtime won't be allocated until a task is
     /// spawned.
     static ASYNC_RUNTIME: RefCell<Option<AsyncRuntime>> = RefCell::new(Some(AsyncRuntime::new()));
@@ -346,7 +346,7 @@ trait WithRuntime {
     fn with_runtime_mut<R>(&'static self, f: impl FnOnce(&mut AsyncRuntime) -> R) -> R;
 }
 
-impl WithRuntime for LocalKey<RefCell<Option<AsyncRuntime>>> {
+impl WithRuntime for crate::private::GodotThreadLocal<RefCell<Option<AsyncRuntime>>> {
     fn with_runtime<R>(&'static self, f: impl FnOnce(&AsyncRuntime) -> R) -> R {
         self.with_borrow(|rt| {
             let rt_ref = rt.as_ref().expect(ASYNC_RUNTIME_DEINIT_PANIC_MESSAGE);