Avoid a global mutable static

src/lib.rs

@@ -40,6 +40,7 @@
 
 use std::collections::{HashMap, HashSet};
 use std::future::Future;
+use std::panic::AssertUnwindSafe;
 use std::pin::Pin;
 
 mod exec;
@@ -214,7 +215,7 @@
     last_frame_time: f64,
     frame_time: f64,
 
     #[cfg(one_screenshot)]
     counter: usize,
 
     camera_stack: Vec<camera::CameraState>,
@@ -356,7 +357,7 @@
             last_frame_time: miniquad::date::now(),
             frame_time: 1. / 60.,
 
             #[cfg(one_screenshot)]
             counter: 0,
             unwind: false,
             recovery_future: None,
@@ -406,7 +407,7 @@
 
         get_quad_context().commit_frame();
 
         #[cfg(one_screenshot)]
         {
             get_context().counter += 1;
             if get_context().counter == 3 {
@@ -481,29 +482,21 @@
 fn get_context() -> &'static mut Context {
     thread_assert::same_thread();
 
     unsafe { CONTEXT.as_mut().unwrap_or_else(|| panic!()) }
 }
 
 fn get_quad_context() -> &'static mut dyn miniquad::RenderingBackend {
     thread_assert::same_thread();
 
     unsafe {
         assert!(CONTEXT.is_some());
     }
 
     unsafe { &mut *CONTEXT.as_mut().unwrap().quad_context }
 }
 
-static mut MAIN_FUTURE: Option<Pin<Box<dyn Future<Output = ()>>>> = None;
-
-struct Stage {}
-
-impl Drop for Stage {
-    fn drop(&mut self) {
-        unsafe {
-            MAIN_FUTURE.take();
-        }
-    }
+struct Stage {
+    main_future: Pin<Box<dyn Future<Output = ()>>>,
 }
 
 impl EventHandler for Stage {
@@ -727,26 +720,23 @@
                 }
             }
 
-            let result = maybe_unwind(get_context().unwind, || {
-                if let Some(future) = unsafe { MAIN_FUTURE.as_mut() } {
+            let result = maybe_unwind(
+                get_context().unwind,
+                AssertUnwindSafe(|| {
                     let _z = telemetry::ZoneGuard::new("Event::draw user code");
 
-                    if exec::resume(future).is_some() {
-                        unsafe {
-                            MAIN_FUTURE = None;
-                        }
+                    if exec::resume(&mut self.main_future).is_some() {
+                        self.main_future = Box::pin(async move {});
                         miniquad::window::quit();
                         return;
                     }
                     get_context().coroutines_context.update();
-                }
-            });
+                }),
+            );
 
             if result == false {
                 if let Some(recovery_future) = get_context().recovery_future.take() {
-                    unsafe {
-                        MAIN_FUTURE = Some(recovery_future);
-                    }
+                    self.main_future = recovery_future;
                 }
             }
 
@@ -882,9 +872,6 @@
         } = config.into();
         miniquad::start(miniquad_conf, move || {
             thread_assert::set_thread_id();
-            unsafe {
-                MAIN_FUTURE = Some(Box::pin(future));
-            }
             let context = Context::new(
                 update_on.unwrap_or_default(),
                 default_filter_mode,
@@ -893,7 +880,9 @@
             );
             unsafe { CONTEXT = Some(context) };
 
-            Box::new(Stage {})
+            Box::new(Stage {
+                main_future: Box::pin(future),
+            })
         });
     }
 }