Final optimizations and dependency cleanup for mlua-luau-scheduler

Cargo.lock

@@ -1992,8 +1992,6 @@ dependencies = [
  "async-fs",
  "async-io",
  "blocking",
- "concurrent-queue",
- "event-listener",
  "futures-lite",
  "mlua",
  "rustc-hash 2.1.1",

crates/mlua-luau-scheduler/Cargo.toml

@@ -18,8 +18,6 @@ workspace = true
 [dependencies]
 async-executor = "1.13"
 blocking = "1.6"
-concurrent-queue = "2.5"
-event-listener = "5.4"
 futures-lite = "2.6"
 rustc-hash = "2.1"
 tracing = "0.1"

crates/mlua-luau-scheduler/src/events/mod.rs

@@ -0,0 +1,5 @@
+mod multi;
+mod once;
+
+pub(crate) use self::multi::MultiEvent;
+pub(crate) use self::once::OnceEvent;

crates/mlua-luau-scheduler/src/events/multi.rs

@@ -8,10 +8,10 @@ use std::{
 };
 
 /**
-    Internal state for queue events.
+    Internal state for events.
 */
 #[derive(Debug, Default)]
-struct QueueEventState {
+struct MultiEventState {
     generation: Cell<u64>,
     wakers: RefCell<Vec<Waker>>,
 }
@@ -20,11 +20,11 @@ struct QueueEventState {
     A single-threaded event signal that can be notified multiple times.
 */
 #[derive(Debug, Clone, Default)]
-pub(crate) struct QueueEvent {
-    state: Rc<QueueEventState>,
+pub(crate) struct MultiEvent {
+    state: Rc<MultiEventState>,
 }
 
-impl QueueEvent {
+impl MultiEvent {
     /**
         Creates a new event.
     */
@@ -51,8 +51,8 @@ impl QueueEvent {
     /**
         Creates a listener that implements `Future` and resolves when `notify` is called.
     */
-    pub fn listen(&self) -> QueueListener {
-        QueueListener {
+    pub fn listen(&self) -> MultiListener {
+        MultiListener {
             state: self.state.clone(),
             generation: self.state.generation.get(),
         }
@@ -63,12 +63,12 @@ impl QueueEvent {
     A listener future that resolves when the corresponding [`QueueEvent`] is notified.
 */
 #[derive(Debug)]
-pub(crate) struct QueueListener {
-    state: Rc<QueueEventState>,
+pub(crate) struct MultiListener {
+    state: Rc<MultiEventState>,
     generation: u64,
 }
 
-impl Future for QueueListener {
+impl Future for MultiListener {
     type Output = ();
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
@@ -88,4 +88,4 @@ impl Future for QueueListener {
     }
 }
 
-impl Unpin for QueueListener {}
+impl Unpin for MultiListener {}

crates/mlua-luau-scheduler/src/exit.rs

@@ -1,24 +1,24 @@
 use std::{cell::Cell, rc::Rc};
 
-use event_listener::Event;
+use crate::events::OnceEvent;
 
 #[derive(Debug, Clone)]
 pub(crate) struct Exit {
     code: Rc<Cell<Option<u8>>>,
-    event: Rc<Event>,
+    event: OnceEvent,
 }
 
 impl Exit {
     pub fn new() -> Self {
         Self {
             code: Rc::new(Cell::new(None)),
-            event: Rc::new(Event::new()),
+            event: OnceEvent::new(),
         }
     }
 
     pub fn set(&self, code: u8) {
         self.code.set(Some(code));
-        self.event.notify(usize::MAX);
+        self.event.notify();
     }
 
     pub fn get(&self) -> Option<u8> {

crates/mlua-luau-scheduler/src/lib.rs

@@ -1,6 +1,7 @@
 #![allow(clippy::cargo_common_metadata)]
 
 mod error_callback;
+mod events;
 mod exit;
 mod functions;
 mod queue;

crates/mlua-luau-scheduler/src/queue/futures.rs

@@ -2,20 +2,20 @@ use std::{cell::RefCell, mem, pin::Pin, rc::Rc};
 
 use futures_lite::prelude::*;
 
-use super::event::QueueEvent;
+use crate::events::MultiEvent;
 
 pub type LocalBoxFuture<'fut> = Pin<Box<dyn Future<Output = ()> + 'fut>>;
 
 struct FuturesQueueInner<'fut> {
     queue: RefCell<Vec<LocalBoxFuture<'fut>>>,
-    event: QueueEvent,
+    event: MultiEvent,
 }
 
 impl FuturesQueueInner<'_> {
     pub fn new() -> Self {
         Self {
             queue: RefCell::new(Vec::new()),
-            event: QueueEvent::new(),
+            event: MultiEvent::new(),
         }
     }
 }

crates/mlua-luau-scheduler/src/queue/mod.rs

@@ -1,5 +1,4 @@
 mod deferred;
-mod event;
 mod futures;
 mod spawned;
 mod threads;

crates/mlua-luau-scheduler/src/queue/threads.rs

@@ -6,19 +6,19 @@ use mlua::prelude::*;
 
 use crate::{threads::ThreadId, traits::IntoLuaThread};
 
-use super::event::QueueEvent;
+use crate::events::MultiEvent;
 
 #[derive(Debug)]
 struct ThreadQueueInner {
     queue: RefCell<Vec<(LuaThread, LuaMultiValue)>>,
-    event: QueueEvent,
+    event: MultiEvent,
 }
 
 impl ThreadQueueInner {
     fn new() -> Self {
         Self {
             queue: RefCell::new(Vec::new()),
-            event: QueueEvent::new(),
+            event: MultiEvent::new(),
         }
     }
 }

crates/mlua-luau-scheduler/src/threads/map.rs

@@ -5,7 +5,8 @@ use std::{cell::RefCell, rc::Rc};
 use mlua::prelude::*;
 use rustc_hash::FxHashMap;
 
-use super::{event::OnceEvent, id::ThreadId};
+use super::id::ThreadId;
+use crate::events::OnceEvent;
 
 struct ThreadEvent {
     result: Option<LuaResult<LuaMultiValue>>,

crates/mlua-luau-scheduler/src/threads/mod.rs

@@ -1,4 +1,3 @@
-mod event;
 mod id;
 mod map;