type aliasing

Author: joshua-spacetime

crates/core/src/host/v8/mod.rs

@@ -319,14 +319,14 @@ impl JsInstance {
 
     async fn send_request<T>(
         &self,
-        request: impl FnOnce(oneshot::Sender<WorkerReply<T>>) -> JsWorkerRequest,
+        request: impl FnOnce(JsReplyTx<T>) -> JsWorkerRequest,
     ) -> Result<T, WorkerDisconnected> {
         let (reply_tx, reply_rx) = oneshot::channel();
         self.request_tx
             .send_async(request(reply_tx))
             .await
             .map_err(|_| WorkerDisconnected)?;
-        let WorkerReply { value, trapped } = reply_rx.await.map_err(|_| WorkerDisconnected)?;
+        let JsWorkerReply { value, trapped } = reply_rx.await.map_err(|_| WorkerDisconnected)?;
         if trapped {
             self.trapped.store(true, Ordering::Relaxed);
         }
@@ -456,60 +456,67 @@ impl JsInstance {
 #[derive(Clone, Copy, Debug)]
 struct WorkerDisconnected;
 
-struct WorkerReply<T> {
+struct JsWorkerReply<T> {
     value: T,
     trapped: bool,
 }
 
+type JsReplyTx<T> = oneshot::Sender<JsWorkerReply<T>>;
+
+/// Requests sent to the dedicated JS worker thread.
+///
+/// Most variants carry a `reply_tx` because the worker thread owns the isolate,
+/// executes the request there, and then has to send both the typed result and
+/// the worker's trapped-bit back to the async caller.
 enum JsWorkerRequest {
     RunFunction(Box<dyn FnOnce() -> LocalBoxFuture<'static, ()> + Send>),
     UpdateDatabase {
-        reply_tx: oneshot::Sender<WorkerReply<anyhow::Result<UpdateDatabaseResult>>>,
+        reply_tx: JsReplyTx<anyhow::Result<UpdateDatabaseResult>>,
         program: Program,
         old_module_info: Arc<ModuleInfo>,
         policy: MigrationPolicy,
     },
     CallReducer {
-        reply_tx: oneshot::Sender<WorkerReply<ReducerCallResult>>,
+        reply_tx: JsReplyTx<ReducerCallResult>,
         params: CallReducerParams,
     },
     CallView {
-        reply_tx: oneshot::Sender<WorkerReply<ViewCommandResult>>,
+        reply_tx: JsReplyTx<ViewCommandResult>,
         cmd: ViewCommand,
     },
     CallProcedure {
-        reply_tx: oneshot::Sender<WorkerReply<CallProcedureReturn>>,
+        reply_tx: JsReplyTx<CallProcedureReturn>,
         params: CallProcedureParams,
     },
-    ClearAllClients(oneshot::Sender<WorkerReply<anyhow::Result<()>>>),
+    ClearAllClients(JsReplyTx<anyhow::Result<()>>),
     CallIdentityConnected {
-        reply_tx: oneshot::Sender<WorkerReply<Result<(), ClientConnectedError>>>,
+        reply_tx: JsReplyTx<Result<(), ClientConnectedError>>,
         caller_auth: ConnectionAuthCtx,
         caller_connection_id: ConnectionId,
     },
     CallIdentityDisconnected {
-        reply_tx: oneshot::Sender<WorkerReply<Result<(), ReducerCallError>>>,
+        reply_tx: JsReplyTx<Result<(), ReducerCallError>>,
         caller_identity: Identity,
         caller_connection_id: ConnectionId,
     },
     DisconnectClient {
-        reply_tx: oneshot::Sender<WorkerReply<Result<(), ReducerCallError>>>,
+        reply_tx: JsReplyTx<Result<(), ReducerCallError>>,
         client_id: ClientActorId,
     },
     InitDatabase {
-        reply_tx: oneshot::Sender<WorkerReply<anyhow::Result<Option<ReducerCallResult>>>>,
+        reply_tx: JsReplyTx<anyhow::Result<Option<ReducerCallResult>>>,
         program: Program,
     },
     CallScheduledFunction {
-        reply_tx: oneshot::Sender<WorkerReply<CallScheduledFunctionResult>>,
+        reply_tx: JsReplyTx<CallScheduledFunctionResult>,
         params: ScheduledFunctionParams,
     },
 }
 
 static_assert_size!(CallReducerParams, 192);
 
-fn send_worker_reply<T>(ctx: &str, reply_tx: oneshot::Sender<WorkerReply<T>>, value: T, trapped: bool) {
-    if reply_tx.send(WorkerReply { value, trapped }).is_err() {
+fn send_worker_reply<T>(ctx: &str, reply_tx: JsReplyTx<T>, value: T, trapped: bool) {
+    if reply_tx.send(JsWorkerReply { value, trapped }).is_err() {
         log::error!("should have receiver for `{ctx}` response");
     }
 }