Remove ExtensionLibrary::override_hot_reload()

This API is rather complex to use, and there's no indication that the customization
is needed. If the need arises again, we should first consider improving the default
behavior (e.g. Godot Editor/Export builds rather than Rust Debug/Release).

Author: Bromeon

godot-core/src/init/mod.rs

@@ -31,11 +31,7 @@ pub unsafe fn __gdext_load_library<E: ExtensionLibrary>(
         // cause TLS-destructors to run then we have a setting already for how to deal with them. Otherwise, this could cause the default
         // behavior to kick in and disable hot reloading.
         #[cfg(target_os = "linux")]
-        match E::override_hot_reload() {
-            None => sys::linux_reload_workaround::default_set_hot_reload(),
-            Some(true) => sys::linux_reload_workaround::enable_hot_reload(),
-            Some(false) => sys::linux_reload_workaround::disable_hot_reload(),
-        }
+        sys::linux_reload_workaround::default_set_hot_reload();
 
         let tool_only_in_editor = match E::editor_run_behavior() {
             EditorRunBehavior::ToolClassesOnly => true,
@@ -323,20 +319,6 @@ pub unsafe trait ExtensionLibrary {
     fn override_wasm_binary() -> Option<&'static str> {
         None
     }
-
-    /// Whether to enable hot reloading of this library. Return `None` to use the default behavior.
-    ///
-    /// Enabling this will ensure that the library can be hot reloaded. If this is disabled then hot reloading may still work, but there is no
-    /// guarantee. Enabling this may also lead to memory leaks, so it should not be enabled for builds that are intended to be final builds.
-    ///
-    /// By default, this is enabled for debug builds and disabled for release builds.
-    ///
-    /// Note that this is only checked *once* upon initializing the library. Changing this from `true` to `false` will be picked up as the
-    /// library is then fully reloaded upon hot-reloading, however changing it from `false` to `true` is almost certainly not going to work
-    /// unless hot-reloading is already working regardless of this setting.
-    fn override_hot_reload() -> Option<bool> {
-        None
-    }
 }
 
 /// Determines if and how an extension's code is run in the editor.

godot-ffi/src/linux_reload_workaround.rs

@@ -15,41 +15,48 @@
 use std::ffi::c_void;
 use std::sync::OnceLock;
 
-pub type ThreadAtexitFn = unsafe extern "C" fn(*mut c_void, *mut c_void, *mut c_void);
-
 static SYSTEM_THREAD_ATEXIT: OnceLock<Option<ThreadAtexitFn>> = OnceLock::new();
 static HOT_RELOADING_ENABLED: OnceLock<bool> = OnceLock::new();
 
-fn system_thread_atexit() -> &'static Option<ThreadAtexitFn> {
-    SYSTEM_THREAD_ATEXIT.get_or_init(|| unsafe {
-        let name = c"__cxa_thread_atexit_impl".as_ptr();
-        std::mem::transmute(libc::dlsym(libc::RTLD_NEXT, name))
-    })
-}
-
-pub fn enable_hot_reload() {
-    // If hot reloading is enabled then we should properly unload the library, so this will only be called once.
-    HOT_RELOADING_ENABLED
-        .set(true)
-        .expect("hot reloading should only be set once")
-}
-
-pub fn disable_hot_reload() {
-    // If hot reloading is disabled then we may call this method multiple times.
-    _ = HOT_RELOADING_ENABLED.set(false)
-}
-
 pub fn default_set_hot_reload() {
     // By default, we enable hot reloading for debug builds, as it's likely that the user may want hot reloading in debug builds.
     // Release builds however should avoid leaking memory, so we disable hot reloading support by default.
+    // In the future, this might consider the .gdextension `is_reloadable` flag, or whether Godot is using an editor or export build.
     if cfg!(debug_assertions) {
         enable_hot_reload()
     } else {
         disable_hot_reload()
     }
 }
 
-fn is_hot_reload_enabled() -> bool {
+// ----------------------------------------------------------------------------------------------------------------------------------------------
+// Publicly accessible
+
+#[macro_export]
+macro_rules! register_hot_reload_workaround {
+    () => {
+        #[no_mangle]
+        #[doc(hidden)]
+        pub unsafe extern "C" fn __cxa_thread_atexit_impl(
+            func: *mut ::std::ffi::c_void,
+            obj: *mut ::std::ffi::c_void,
+            dso_symbol: *mut ::std::ffi::c_void,
+        ) {
+            $crate::linux_reload_workaround::thread_atexit(func, obj, dso_symbol);
+        }
+    };
+}
+
+type ThreadAtexitFn = unsafe extern "C" fn(*mut c_void, *mut c_void, *mut c_void);
+
+pub fn system_thread_atexit() -> &'static Option<ThreadAtexitFn> {
+    SYSTEM_THREAD_ATEXIT.get_or_init(|| unsafe {
+        let name = c"__cxa_thread_atexit_impl".as_ptr();
+        std::mem::transmute(libc::dlsym(libc::RTLD_NEXT, name))
+    })
+}
+
+pub fn is_hot_reload_enabled() -> bool {
     // Assume hot reloading is disabled unless something else has been specified already. This is the better default as thread local storage
     // destructors exist for good reasons.
     // This is needed for situations like unit-tests, where we may create TLS-destructors without explicitly calling any of the methods
@@ -78,17 +85,17 @@ pub unsafe fn thread_atexit(func: *mut c_void, obj: *mut c_void, dso_symbol: *mu
     }
 }
 
-#[macro_export]
-macro_rules! register_hot_reload_workaround {
-    () => {
-        #[no_mangle]
-        #[doc(hidden)]
-        pub unsafe extern "C" fn __cxa_thread_atexit_impl(
-            func: *mut ::std::ffi::c_void,
-            obj: *mut ::std::ffi::c_void,
-            dso_symbol: *mut ::std::ffi::c_void,
-        ) {
-            $crate::linux_reload_workaround::thread_atexit(func, obj, dso_symbol);
-        }
-    };
+// ----------------------------------------------------------------------------------------------------------------------------------------------
+// Implementation
+
+fn enable_hot_reload() {
+    // If hot reloading is enabled then we should properly unload the library, so this will only be called once.
+    HOT_RELOADING_ENABLED
+        .set(true)
+        .expect("hot reloading should only be set once")
+}
+
+fn disable_hot_reload() {
+    // If hot reloading is disabled then we may call this method multiple times.
+    _ = HOT_RELOADING_ENABLED.set(false)
 }