refactor: rename async_run to background_run & sync_run to main_run

web-infra-dev · Nov 9, 2024 · 4ed3ab1 · 4ed3ab1
1 parent 2ac4a11
commit 4ed3ab1
Show file tree

Hide file tree

Showing 9 changed files with 25 additions and 27 deletions.
diff --git a/crates/rspack_core/src/compiler/make/repair/add.rs b/crates/rspack_core/src/compiler/make/repair/add.rs
@@ -21,7 +21,7 @@ impl Task<MakeTaskContext> for AddTask {
   fn get_task_type(&self) -> TaskType {
     TaskType::Sync
   }
-  async fn sync_run(self: Box<Self>, context: &mut MakeTaskContext) -> TaskResult<MakeTaskContext> {
+  async fn main_run(self: Box<Self>, context: &mut MakeTaskContext) -> TaskResult<MakeTaskContext> {
     let module_identifier = self.module.identifier();
     let artifact = &mut context.artifact;
     let module_graph =

diff --git a/crates/rspack_core/src/compiler/make/repair/build.rs b/crates/rspack_core/src/compiler/make/repair/build.rs
@@ -26,7 +26,7 @@ impl Task<MakeTaskContext> for BuildTask {
   fn get_task_type(&self) -> TaskType {
     TaskType::Async
   }
-  async fn async_run(self: Box<Self>) -> TaskResult<MakeTaskContext> {
+  async fn background_run(self: Box<Self>) -> TaskResult<MakeTaskContext> {
     let Self {
       compilation_id,
       compiler_options,
@@ -102,7 +102,7 @@ impl Task<MakeTaskContext> for BuildResultTask {
   fn get_task_type(&self) -> TaskType {
     TaskType::Sync
   }
-  async fn sync_run(self: Box<Self>, context: &mut MakeTaskContext) -> TaskResult<MakeTaskContext> {
+  async fn main_run(self: Box<Self>, context: &mut MakeTaskContext) -> TaskResult<MakeTaskContext> {
     let BuildResultTask {
       mut module,
       build_result,

diff --git a/crates/rspack_core/src/compiler/make/repair/factorize.rs b/crates/rspack_core/src/compiler/make/repair/factorize.rs
@@ -33,7 +33,7 @@ impl Task<MakeTaskContext> for FactorizeTask {
   fn get_task_type(&self) -> TaskType {
     TaskType::Async
   }
-  async fn async_run(self: Box<Self>) -> TaskResult<MakeTaskContext> {
+  async fn background_run(self: Box<Self>) -> TaskResult<MakeTaskContext> {
     if let Some(current_profile) = &self.current_profile {
       current_profile.mark_factory_start();
     }
@@ -204,7 +204,7 @@ impl Task<MakeTaskContext> for FactorizeResultTask {
   fn get_task_type(&self) -> TaskType {
     TaskType::Sync
   }
-  async fn sync_run(self: Box<Self>, context: &mut MakeTaskContext) -> TaskResult<MakeTaskContext> {
+  async fn main_run(self: Box<Self>, context: &mut MakeTaskContext) -> TaskResult<MakeTaskContext> {
     let FactorizeResultTask {
       original_module_identifier,
       factory_result,

diff --git a/crates/rspack_core/src/compiler/make/repair/process_dependencies.rs b/crates/rspack_core/src/compiler/make/repair/process_dependencies.rs
@@ -19,7 +19,7 @@ impl Task<MakeTaskContext> for ProcessDependenciesTask {
     TaskType::Sync
   }
 
-  async fn sync_run(self: Box<Self>, context: &mut MakeTaskContext) -> TaskResult<MakeTaskContext> {
+  async fn main_run(self: Box<Self>, context: &mut MakeTaskContext) -> TaskResult<MakeTaskContext> {
     let Self {
       original_module_identifier,
       dependencies,

diff --git a/crates/rspack_core/src/compiler/module_executor/ctrl.rs b/crates/rspack_core/src/compiler/module_executor/ctrl.rs
@@ -104,7 +104,7 @@ impl Task<MakeTaskContext> for CtrlTask {
     TaskType::Async
   }
 
-  async fn async_run(mut self: Box<Self>) -> TaskResult<MakeTaskContext> {
+  async fn background_run(mut self: Box<Self>) -> TaskResult<MakeTaskContext> {
     while let Some(event) = self.event_receiver.recv().await {
       tracing::info!("CtrlTask async receive {:?}", event);
       match event {
@@ -202,7 +202,7 @@ impl Task<MakeTaskContext> for FinishModuleTask {
     TaskType::Sync
   }
 
-  async fn sync_run(self: Box<Self>, context: &mut MakeTaskContext) -> TaskResult<MakeTaskContext> {
+  async fn main_run(self: Box<Self>, context: &mut MakeTaskContext) -> TaskResult<MakeTaskContext> {
     let Self {
       mut ctrl_task,
       module_identifier,

diff --git a/crates/rspack_core/src/compiler/module_executor/entry.rs b/crates/rspack_core/src/compiler/module_executor/entry.rs
@@ -15,7 +15,7 @@ impl Task<MakeTaskContext> for EntryTask {
     TaskType::Sync
   }
 
-  async fn sync_run(self: Box<Self>, context: &mut MakeTaskContext) -> TaskResult<MakeTaskContext> {
+  async fn main_run(self: Box<Self>, context: &mut MakeTaskContext) -> TaskResult<MakeTaskContext> {
     let Self { dep, layer } = *self;
     let mut module_graph =
       MakeTaskContext::get_module_graph_mut(&mut context.artifact.module_graph_partial);

diff --git a/crates/rspack_core/src/compiler/module_executor/execute.rs b/crates/rspack_core/src/compiler/module_executor/execute.rs
@@ -60,7 +60,7 @@ impl Task<MakeTaskContext> for ExecuteTask {
     TaskType::Sync
   }
 
-  async fn sync_run(self: Box<Self>, context: &mut MakeTaskContext) -> TaskResult<MakeTaskContext> {
+  async fn main_run(self: Box<Self>, context: &mut MakeTaskContext) -> TaskResult<MakeTaskContext> {
     let Self {
       entry_dep_id,
       layer,

diff --git a/crates/rspack_core/src/compiler/module_executor/overwrite.rs b/crates/rspack_core/src/compiler/module_executor/overwrite.rs
@@ -21,7 +21,7 @@ impl Task<MakeTaskContext> for OverwriteTask {
     self.origin_task.get_task_type()
   }
 
-  async fn sync_run(self: Box<Self>, context: &mut MakeTaskContext) -> TaskResult<MakeTaskContext> {
+  async fn main_run(self: Box<Self>, context: &mut MakeTaskContext) -> TaskResult<MakeTaskContext> {
     let Self {
       origin_task,
       event_sender,
@@ -32,7 +32,7 @@ impl Task<MakeTaskContext> for OverwriteTask {
       .downcast_ref::<ProcessDependenciesTask>()
     {
       let original_module_identifier = process_dependencies_task.original_module_identifier;
-      let res = origin_task.sync_run(context).await?;
+      let res = origin_task.main_run(context).await?;
       event_sender
         .send(Event::FinishModule(original_module_identifier, res.len()))
         .expect("should success");
@@ -44,7 +44,7 @@ impl Task<MakeTaskContext> for OverwriteTask {
     {
       let dep_id = *factorize_result_task.dependencies[0].id();
       let original_module_identifier = factorize_result_task.original_module_identifier;
-      let res = origin_task.sync_run(context).await?;
+      let res = origin_task.main_run(context).await?;
       if res.is_empty() {
         event_sender
           .send(Event::FinishDeps(original_module_identifier, dep_id, None))
@@ -58,7 +58,7 @@ impl Task<MakeTaskContext> for OverwriteTask {
       let original_module_identifier = add_task.original_module_identifier;
       let target_module_identifier = add_task.module.identifier();
 
-      let res = origin_task.sync_run(context).await?;
+      let res = origin_task.main_run(context).await?;
       if res.is_empty() {
         event_sender
           .send(Event::FinishDeps(
@@ -76,10 +76,10 @@ impl Task<MakeTaskContext> for OverwriteTask {
     }
 
     // other task
-    origin_task.sync_run(context).await
+    origin_task.main_run(context).await
   }
 
-  async fn async_run(self: Box<Self>) -> TaskResult<MakeTaskContext> {
-    self.origin_task.async_run().await
+  async fn background_run(self: Box<Self>) -> TaskResult<MakeTaskContext> {
+    self.origin_task.background_run().await
   }
 }
diff --git a/crates/rspack_core/src/utils/task_loop.rs b/crates/rspack_core/src/utils/task_loop.rs
@@ -36,15 +36,13 @@ pub trait Task<Ctx>: Debug + Send + Any + AsAny {
   /// Return `TaskType::Async` will run `self::async_run`
   fn get_task_type(&self) -> TaskType;
 
-  /// Sync task process
-  ///
-  /// The context is shared with all tasks
-  async fn sync_run(self: Box<Self>, _context: &mut Ctx) -> TaskResult<Ctx> {
+  /// can be running in main thread
+  async fn main_run(self: Box<Self>, _context: &mut Ctx) -> TaskResult<Ctx> {
     unreachable!();
   }
 
-  /// Async task process
-  async fn async_run(self: Box<Self>) -> TaskResult<Ctx> {
+  /// can be running in background thread
+  async fn background_run(self: Box<Self>) -> TaskResult<Ctx> {
     unreachable!();
   }
 }
@@ -84,15 +82,15 @@ pub async fn run_task_loop_with_event<Ctx: 'static>(
           let is_expected_shutdown = is_expected_shutdown.clone();
           active_task_count += 1;
           tokio::spawn(async move {
-            let r = task.async_run().await;
+            let r = task.background_run().await;
             if !is_expected_shutdown.load(Ordering::Relaxed) {
               tx.send(r).expect("failed to send error message");
             }
           });
         }
         TaskType::Sync => {
           // merge sync task result directly
-          match task.sync_run(ctx).await {
+          match task.main_run(ctx).await {
             Ok(r) => queue.extend(r),
             Err(e) => {
               is_expected_shutdown.store(true, Ordering::Relaxed);
@@ -151,7 +149,7 @@ mod test {
     fn get_task_type(&self) -> TaskType {
       TaskType::Sync
     }
-    async fn sync_run(self: Box<Self>, context: &mut Context) -> TaskResult<Context> {
+    async fn main_run(self: Box<Self>, context: &mut Context) -> TaskResult<Context> {
       if context.sync_return_error {
         return Err(miette!("throw sync error"));
       }
@@ -177,7 +175,7 @@ mod test {
     fn get_task_type(&self) -> TaskType {
       TaskType::Async
     }
-    async fn async_run(self: Box<Self>) -> TaskResult<Context> {
+    async fn background_run(self: Box<Self>) -> TaskResult<Context> {
       tokio::time::sleep(std::time::Duration::from_millis(10)).await;
       if self.async_return_error {
         Err(miette!("throw async error"))