Global main thread ID

Author: TitanNano

godot-core/build.rs

@@ -17,4 +17,5 @@ fn main() {
     println!("cargo:rerun-if-changed=build.rs");
 
     godot_bindings::emit_godot_version_cfg();
+    godot_bindings::emit_wasm_nothreads_cfg();
 }

godot-core/src/init/mod.rs

@@ -34,6 +34,14 @@ pub unsafe fn __gdext_load_library<E: ExtensionLibrary>(
             Some(false) => sys::linux_reload_workaround::disable_hot_reload(),
         }
 
+        // We want to initialize the main thread ID as early as possible, but it has to happen after the hot-reload workaround.
+        //
+        // SAFETY: We set the main thread ID exactly once during library initialization and never again.
+        #[cfg(not(wasm_nothreads))]
+        unsafe {
+            crate::meta::MAIN_THREAD_ID.set(std::thread::current().id())
+        };
+
         let tool_only_in_editor = match E::editor_run_behavior() {
             EditorRunBehavior::ToolClassesOnly => true,
             EditorRunBehavior::AllClasses => false,

godot-core/src/meta/mod.rs

@@ -81,6 +81,19 @@ pub use signature::trace;
 pub use method_info::MethodInfo;
 pub use property_info::{PropertyHintInfo, PropertyInfo};
 
+#[cfg(not(wasm_nothreads))]
+pub(crate) static MAIN_THREAD_ID: crate::sys::ManualInitCell<std::thread::ThreadId> =
+    crate::sys::ManualInitCell::new();
+
+/// Get the [`ThreadId`](std::thread::ThreadId) of the main thread.
+#[cfg(not(wasm_nothreads))]
+pub fn main_thread_id() -> std::thread::ThreadId {
+    // SAFETY: We initialized the cell during library initialization, before any other code is executed.
+    let thread_id = unsafe { MAIN_THREAD_ID.get_unchecked() };
+
+    *thread_id
+}
+
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 
 /// Clean up various resources at end of usage.

godot-ffi/src/toolbox.rs

@@ -439,7 +439,7 @@ mod manual_init_cell {
     /// seems able to optimize `OnceLock` to equivalent code. But this guaranteed does not have any overhead at runtime.
     ///
     /// This cell additionally allows to deinitialize the value. Access to uninitialized values is UB, but checked in Debug mode.
-    pub(crate) struct ManualInitCell<T> {
+    pub struct ManualInitCell<T> {
         // Invariant: Is `None` until initialized, and then never modified after (except, possibly, through interior mutability).
         cell: UnsafeCell<Option<T>>,
     }
@@ -529,9 +529,15 @@ mod manual_init_cell {
     unsafe impl<T: Send + Sync> Sync for ManualInitCell<T> {}
     // SAFETY: See `Sync` impl.
     unsafe impl<T: Send> Send for ManualInitCell<T> {}
+
+    impl<T> Default for ManualInitCell<T> {
+        fn default() -> Self {
+            Self::new()
+        }
+    }
 }
 
-pub(crate) use manual_init_cell::ManualInitCell;
+pub use manual_init_cell::ManualInitCell;
 
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Unit tests